import { A as TActionProgress } from "./ChannelAcceptor-Cmu6jyhn.mjs";
import { IRuntimeCoordinate } from "@nice-code/wire";

//#region ../nice-devtools-core/build/index.d.mts
//#endregion
//#region src/traffic/traffic.types.d.ts
type TTrafficDir = "in" | "out";
/**
 * One observed frame/message. `bytes` is whatever the tap measured — the raw
 * carrier frame (true wire bytes, post-encryption) or a decoded payload; the
 * two kinds of tap feed separate cores (or separate lanes) so the numbers stay
 * honestly labelled.
 */
interface ITrafficSample {
  /** `Date.now()` at observation. */
  atMs: number;
  dir: TTrafficDir;
  bytes: number;
  /** Coarse attribution — "action" | "realm" | "handshake" | "keepalive" | "control" | "http" | a realm label… */
  lane: string;
  /** Finer attribution when known — e.g. a realm frame kind ("patches", "write", "hydrate"). */
  kind?: string;
  /** Link/connection identity, for multi-link apps and per-connection server stats. */
  linkId?: string;
}
interface ITrafficDirStats {
  count: number;
  bytes: number;
}
interface ITrafficRateStats extends ITrafficDirStats {
  msgsPerSec: number;
  bytesPerSec: number;
}
/** In/out totals + rates over one rolling window, all lanes combined. */
interface ITrafficWindowTotals {
  windowMs: number;
  in: ITrafficRateStats;
  out: ITrafficRateStats;
}
interface ITrafficKindStats {
  kind: string;
  in: ITrafficDirStats;
  out: ITrafficDirStats;
}
/** Per-lane totals over the snapshot's selected window, with a per-kind breakdown. */
interface ITrafficLaneStats {
  lane: string;
  in: ITrafficRateStats;
  out: ITrafficRateStats;
  kinds: ITrafficKindStats[];
}
/** One lane's contribution to a single link. */
interface ITrafficLinkLaneStats {
  lane: string;
  in: ITrafficDirStats;
  out: ITrafficDirStats;
}
/**
 * Per-**link** totals over the snapshot's selected window — "which client costs what", the
 * question a server's bill answers. `linkId` is the peer's coordinate (`stringId`): on an
 * acceptor the connected client, on a connector the server it dials. Two ids are reserved:
 * {@link TRAFFIC_LINK_HANDSHAKING} and {@link TRAFFIC_LINK_OTHER}.
 */
interface ITrafficLinkStats {
  linkId: string;
  in: ITrafficRateStats;
  out: ITrafficRateStats;
  lanes: ITrafficLinkLaneStats[];
}
/**
 * Frames tapped before a connection binds an identity (the handshake itself) carry no `linkId` —
 * they are real bytes on a real socket, so they get a reserved bucket rather than being dropped.
 * Without it, per-link totals would silently fail to reconcile with the all-lane totals.
 */
/** One 1-second bucket of the charting series (zero-filled where nothing flowed). */
interface ITrafficSeriesPoint {
  atMs: number;
  inCount: number;
  inBytes: number;
  outCount: number;
  outBytes: number;
}
/** One of the N largest frames seen — size and attribution only, never contents. */
interface ITrafficTopFrame {
  atMs: number;
  dir: TTrafficDir;
  bytes: number;
  lane: string;
  kind?: string;
  linkId?: string;
}
interface ITrafficSnapshot {
  /** The window the per-lane breakdown was computed over (`MAX_TRAFFIC_WINDOW_MS` for all-time). */
  windowMs: number;
  /** All-lane totals for every window option incl. MAX (the stat-tile row). */
  windows: ITrafficWindowTotals[];
  /** Per-lane breakdown over `windowMs`, busiest (by combined bytes) first. */
  lanes: ITrafficLaneStats[];
  /**
   * Per-link breakdown over `windowMs`, busiest first — every byte lands in exactly one bucket, so
   * this **sums to the window's all-lane totals** (the reserved `(handshaking)` / `(other links)`
   * buckets exist to keep that true). A client that never stamps a `linkId` reports its whole
   * traffic under `(handshaking)`, which is the signal that per-client attribution is unavailable
   * for it rather than that it sent nothing.
   */
  links: ITrafficLinkStats[];
  /** Charting series, oldest → newest, zero-filled — downsampled + capped to the ring's reach. */
  series: ITrafficSeriesPoint[];
  /** The series bucket width in ms (1s at short windows, coarser as the window grows). */
  seriesBucketMs: number;
  /** The N largest frames on record, largest first. */
  topFrames: ITrafficTopFrame[];
  lifetime: {
    in: ITrafficDirStats;
    out: ITrafficDirStats;
    sinceMs: number;
    /**
     * `sinceMs` marks a **counter reset**, not a first observation — an in-memory host restarted or
     * a hibernating one woke. The MAX view says so rather than implying a lifetime total it does
     * not have. Set by {@link TrafficMetricsCore.markResetFromWake}.
     */
    resetFromWake?: boolean;
  };
}
/**
 * A one-shot transfer of a core's accumulated state (lifetime totals + per-lane
 * accumulators + recent ring buckets + top frames), so a devtools window opened
 * mid-session can seed its mirror core and show MAX numbers matching the host's
 * since-connect totals instead of starting at zero.
 */
interface ITrafficStateTransfer {
  sinceMs: number;
  lifetimeIn: ITrafficDirStats;
  lifetimeOut: ITrafficDirStats;
  lanes: {
    lane: string;
    in: ITrafficDirStats;
    out: ITrafficDirStats;
    kinds: {
      kind: string;
      in: ITrafficDirStats;
      out: ITrafficDirStats;
    }[];
  }[];
  /** Lifetime per-link accumulators. Absent from an older host's transfer — treat as empty. */
  links?: ITrafficLinkTransfer[];
  buckets: {
    sec: number;
    lanes: {
      lane: string;
      in: ITrafficDirStats;
      out: ITrafficDirStats;
      kinds: {
        kind: string;
        in: ITrafficDirStats;
        out: ITrafficDirStats;
      }[];
    }[]; /** Per-link counters for this second. Absent from an older host's transfer. */
    links?: ITrafficLinkTransfer[];
  }[];
  topFrames: ITrafficTopFrame[];
}
interface ITrafficLinkTransfer {
  linkId: string;
  in: ITrafficDirStats;
  out: ITrafficDirStats;
  lanes: ITrafficLinkLaneStats[];
}
/**
 * A compact, ring-free rollup of a core's lifetime totals — what a hibernating host persists so its
 * MAX numbers survive an eviction (`persistCounters`). Deliberately excludes the 1-second ring and
 * top frames: those are cheap to rebuild and expensive to store.
 */
interface ITrafficLifetimeRollup {
  sinceMs: number;
  lifetimeIn: ITrafficDirStats;
  lifetimeOut: ITrafficDirStats;
  lanes: {
    lane: string;
    in: ITrafficDirStats;
    out: ITrafficDirStats;
    kinds: {
      kind: string;
      in: ITrafficDirStats;
      out: ITrafficDirStats;
    }[];
  }[];
  links: ITrafficLinkTransfer[];
} //#endregion
//#region src/traffic/TrafficMetricsCore.d.ts
interface ITrafficMetricsCoreOptions {
  /**
   * Ring size in 1-second buckets — how far back the finite windows/series reach.
   * Default 1800 (30 min, the MAX-view graph cap). MAX *stats* are not ring-bounded
   * (they come from lifetime accumulators), only the graph is.
   */
  ringSeconds?: number;
  /** How many largest-frame records to retain. Default 20. */
  topFrames?: number;
  /** Minimum ms between change notifications. Default 250 (≤ 4 Hz). */
  notifyThrottleMs?: number;
  /**
   * Distinct links tracked before further ones fold into {@link TRAFFIC_LINK_OTHER}. Default 200.
   * The cap is on *lifetime* cardinality, not concurrency: a server churning sockets would otherwise
   * grow one counter per socket it ever saw.
   */
  maxLinks?: number;
}
interface ITrafficSnapshotQuery {
  /** Window for the breakdown/totals (default `MAX_TRAFFIC_WINDOW_MS` — all-time). */
  windowMs?: number;
  /** Restrict everything (windows, lanes, series) to these lanes. */
  lanes?: string[];
}
/**
 * Framework-agnostic collector for wire/protocol traffic. Feed it
 * {@link ITrafficSample}s and it maintains a ring of 1-second buckets (for the
 * finite rolling windows + the charting series) AND unbounded lifetime
 * accumulators per lane×dir×kind (for the MAX / all-time view). The finite "per
 * X" stats are ring sums; MAX stats come from the lifetime accumulators so
 * "since the client connected" totals are exact no matter how long ago that was.
 *
 * The hot path ({@link record}) is a few map lookups and integer adds. Nothing
 * retains payload contents.
 */
declare class TrafficMetricsCore {
  private _ring;
  private readonly _ringSeconds;
  private readonly _topN;
  private readonly _notifyThrottleMs;
  private readonly _maxLinks;
  private _topFrames;
  private _lifetimeIn;
  private _lifetimeOut;
  private _lifetimeLanes;
  private _lifetimeLinks;
  private _sinceMs;
  /** True when `sinceMs` marks a host wake/reset rather than a genuine first-observation. */
  private _resumedFromReset;
  private readonly _listeners;
  private readonly _sampleListeners;
  private _notifyTimer;
  constructor(options?: ITrafficMetricsCoreOptions);
  /**
   * The bucket a sample's `linkId` counts into. An unbound frame (the handshake, tapped before the
   * peer identity exists) gets the reserved handshaking bucket; a new id past `maxLinks` folds into
   * the overflow bucket. Decided once per sample off the *lifetime* map, so the ring and the
   * lifetime accumulators can never disagree about which bucket a frame landed in.
   */
  private _resolveLinkId;
  /** Real (non-reserved) link ids tracked so far — the quantity `maxLinks` bounds. */
  private _distinctLinks;
  /**
   * Adapter for the wire-level tap seams (`connectChannel({ wireTap })` et al.):
   * structurally accepts a nice-wire `IWireTapEvent` and stamps the time. Bound,
   * so it can be passed around detached (`{ wireTap: core.wireTap }`).
   */
  readonly wireTap: (event: {
    dir: TTrafficDir;
    bytes: number;
    lane: string;
    kind?: string;
    linkId?: string;
  }) => void;
  record(sample: ITrafficSample): void;
  /**
   * Observe the raw {@link ITrafficSample} stream (every `record`, unthrottled).
   * The devtools bridge forwards samples to a standalone window that feeds them
   * into its own core, preserving full window-select interactivity remotely.
   */
  observe(listener: (sample: ITrafficSample) => void): () => void;
  getSnapshot(query?: ITrafficSnapshotQuery): ITrafficSnapshot;
  /** Serialize accumulated state for a window backfill (see {@link ITrafficStateTransfer}). */
  exportState(): ITrafficStateTransfer;
  /**
   * A compact lifetime rollup — totals only, no 1-second ring, no top frames. What a hibernating
   * host persists so its MAX numbers survive an eviction (see `persistCounters`). Restore with
   * {@link importLifetimeRollup}.
   */
  exportLifetimeRollup(): ITrafficLifetimeRollup;
  /**
   * Seed the lifetime accumulators from a {@link exportLifetimeRollup} (a woken host restoring its
   * persisted totals). The ring stays empty — the rolling windows and the graph legitimately restart
   * at the wake, only the all-time totals continue. Must be called before any `record`.
   */
  importLifetimeRollup(rollup: ITrafficLifetimeRollup): void;
  /**
   * Declare that `sinceMs` marks a reset (an in-memory host restarted, a Durable Object woke from
   * hibernation and lost its counters) rather than a genuine first observation. The MAX view labels
   * itself accordingly instead of implying a lifetime total it does not have.
   */
  markResetFromWake(): void;
  /** Seed this core from a {@link exportState} transfer (a freshly-opened window). Replaces state. */
  importState(state: ITrafficStateTransfer): void;
  /**
   * Change notification, throttled to at most one call per `notifyThrottleMs`.
   * Listeners receive no payload — call {@link getSnapshot} with the query your
   * view needs (and refresh on a timer too: rolling windows decay with time).
   */
  subscribe(listener: () => void): () => void;
  clear(): void;
  private _maybeRecordTopFrame;
  private _scheduleNotify;
  private _fireNotify;
} //#endregion
//#region src/remote/protocol.d.ts
/** Bumped on any incompatible envelope change; mismatched peers ignore each other gracefully. */
/**
 * Where a devtools message physically arrived from, as judged by the **carrier it came in on** —
 * never by anything the message itself says. That direction is the whole security property: a frame
 * relayed from the other side of the world cannot claim to be `"local"`, because nothing in the
 * frame is consulted.
 *
 * - `"local"` — a same-origin `BroadcastChannel`, or a relay on this machine. Reaching it already
 *   requires being on the dev machine / in the app's own origin.
 * - `"remote"` — a session relay carrier: anyone holding the session token, anywhere. Observation is
 *   the point; mutation is not, so producers refuse commands from here unless told otherwise.
 */
type TDevtoolsOrigin = "local" | "remote";
/** Namespaced BroadcastChannel name for an app key, so two apps on one origin don't cross streams. */
/** Who a host→window message is from — keys per-client mirrors and addresses commands. */
interface IDevtoolsClientIdentity {
  /** Stable for one host page-load. Addresses commands (`to`) and keys per-client state. */
  clientId: string;
  /** Human label, derived from the runtime coordinate (may refine after the handshake). */
  label: string;
  /** Deployment env (e.g. "development"/"staging") — surfaced by Wave E; harmless now. */
  env?: string;
  /** `"frontend"` | `"backend"` — surfaced by Wave E; defaults to frontend. */
  kind?: string;
  /**
   * This host's runtime-coordinate `envId` (e.g. `"demo_backend_basic"`), when it serves one. It is
   * the identity a *client* names when it dials this host, so the topology joins a frontend's realm
   * `peer` to the backend that actually serves it — a `realmId` join cannot (two backends may serve
   * the same realm id, and the traffic then draws on the wrong wire).
   */
  coordEnvId?: string;
  /**
   * Whether this producer runs commands from windows that reached it over a **remote** carrier. A
   * window pairs it with the origin it hears this producer on to grey out controls it knows will be
   * refused, instead of offering buttons that fail.
   *
   * Advisory only — this is the producer *describing* its policy, and a window must never treat it
   * as *being* the policy. The enforcement is at the producer (`DevtoolsBridge`), where the frame's
   * true carrier is known; nothing a window believes can move it.
   */
  allowRemoteCommands?: boolean;
  /**
   * Whether this producer is streaming **leaf values** (`true`) or only shape — structure, sizes and
   * timings with every value replaced by its type (`false`). A deployed producer sets the latter so
   * no value leaves the deployment.
   *
   * Advertised so the *window* can show it. A viewer otherwise has no way to tell "this realm is
   * empty" from "this realm's values were redacted before they reached me", and the difference
   * changes what they should conclude from the screen in front of them. Absent when the producer
   * doesn't say (an older producer, or one with no contents-bearing scopes).
   */
  streamContents?: boolean;
}
/** host → window: the full current (already-cloneable) snapshot for one snapshot-scope. */
/** Why a producer refused a command. One arm today; an enum so a window can branch as it grows. */
type TDevtoolsCommandRejectReason = "remote_commands_disabled";
/**
 * host → window: this producer refused a command, and why.
 *
 * Refusals are **loud on purpose**. A silently-dropped command is the worst outcome available here:
 * the operator sees a control that appears to work, believes the producer's state changed, and reads
 * every subsequent snapshot through that false belief. One reply frame turns that into a visible
 * "no".
 */
//#endregion
//#region src/remote/transport.d.ts
/**
 * A bidirectional message pipe between the app (host) and a devtools window.
 * Deliberately tiny so the same bridge/client work over any carrier — the v1
 * carrier is a same-origin `BroadcastChannel`; a realm-backed carrier can
 * implement this same shape later without the panels noticing.
 */
interface IDevtoolsTransport {
  post(message: unknown): void;
  /**
   * Subscribe to inbound messages. `origin` says how far the message travelled to get here — see
   * {@link TDevtoolsOrigin}. It is supplied by the carrier, so a listener never has to (and never
   * gets to) infer trust from message contents.
   */
  onMessage(listener: (message: unknown, origin: TDevtoolsOrigin) => void): () => void;
  close(): void;
  /**
   * What this carrier is, for trust decisions. Defaults to `"local"` when absent, because every
   * carrier in the codebase *is* local except the one relay-session factory that says otherwise —
   * a default of `"remote"` would make ordinary same-origin devtools read-only for everyone.
   *
   * **A carrier that can be reached from off this machine MUST declare `"remote"`.** Only the
   * carrier itself knows this; nothing downstream can work it out.
   */
  origin?: TDevtoolsOrigin;
}
/**
 * A same-origin `BroadcastChannel` transport. Because BroadcastChannel is
 * strictly same-origin, a page on another origin cannot read this stream — the
 * whole local pop-out path carries no cross-origin exposure. Returns a no-op
 * transport where BroadcastChannel is unavailable (SSR / very old runtimes).
 */
//#endregion
//#region src/remote/DevtoolsBridge.d.ts
/**
 * A structured console-log record a scope can emit for the host's `console`
 * sink. The scope owns the *semantics* (what happened, which fields); the host
 * owns the *when* (timer cadence) and *how* (pretty vs json). `message` is the
 * scope's own human line for `pretty`; `event` + `fields` feed the `json` sink.
 */
interface IDevtoolsLogRecord {
  /** Machine event name, e.g. "realm-traffic", "action-success". */
  event: string;
  /** Optional subject label, e.g. the realm id or the action path. */
  label?: string;
  /** Pre-formatted human line for the `pretty` sink. Falls back to a generic render. */
  message?: string;
  /** Structured fields spread into the `json` sink record. */
  fields?: Record<string, unknown>;
}
/**
 * A snapshot-scope: exposes a devtools core's full state as a cloneable
 * snapshot, notifies when it changes, and applies commands back to the live
 * core. The owning package builds these (e.g. `actionBridgeScope(core)`) so the
 * projection that strips live objects lives next to the core it knows.
 */
interface IDevtoolsSnapshotScope {
  scope: string;
  /** Must return a value safe to clone (live handles/stores already projected away). */
  getSnapshot(): unknown;
  /** Fire `onChange` whenever the snapshot should be re-pushed. */
  subscribe(onChange: () => void): () => void;
  /** Apply a window-originated command to the live core (clear, pause, edit…). */
  applyCommand?(command: unknown): void;
  /**
   * Optional console projection for a server host's `console` sink: return the
   * log records to emit since the previous call (empty if nothing worth logging).
   * The scope tracks its own cursor, so it stays fully typed over its live source
   * — the host only owns the *when* (timer cadence) and *how* (pretty vs json).
   */
  logSince?(): IDevtoolsLogRecord[];
}
/** A sample-scope: streams raw traffic samples (forwarded verbatim to the window's own core). */
//#endregion
//#region src/remote/DevtoolsWindowClient.d.ts
/** One host this window has heard from — drives the client switcher. */
interface IDevtoolsClientInfo extends IDevtoolsClientIdentity {
  scopes: string[];
  lastSeen: number;
  /** True once the host has gone silent past the stale threshold (still listed, greyed). */
  stale: boolean;
  /**
   * The carrier origin this producer's messages arrive on — `"remote"` means we are only hearing it
   * through a session relay, so our commands reach it the same way and it judges them as remote.
   */
  origin: TDevtoolsOrigin;
  /**
   * Whether commands from THIS window would be refused by this producer: it is remote to us and says
   * it does not take remote commands. The UI greys its mutating controls on this.
   *
   * A prediction, not the rule — see {@link IDevtoolsClientIdentity.allowRemoteCommands}. The
   * producer decides, and says so out loud via `onCommandRejected` if we get it wrong.
   */
  readOnly: boolean;
}
/** A command this window sent that its target producer refused. */
interface IDevtoolsCommandRejection {
  /** The producer that refused it. */
  clientId: string;
  /** That producer's human label, for the message shown to the operator. */
  label: string;
  scope: string;
  reason: TDevtoolsCommandRejectReason;
}
/**
 * The window side of the standalone-devtools link. Owns the transport, announces
 * itself (`hello` + heartbeat), and tracks every HOST it hears from as a client
 * (Phase 3) — so one window observes many clients (tabs, multiplayer peers).
 * Snapshots and samples fan out to per-`(client, scope)` handlers (the mirror
 * cores register here); commands are addressed back to one client.
 */
declare class DevtoolsWindowClient {
  private readonly _transport;
  private readonly _consumerId;
  private readonly _snapshotHandlers;
  private readonly _sampleHandlers;
  /** Per-scope handlers that fire for EVERY client (merged traffic / event log). */
  private readonly _anySampleHandlers;
  private readonly _backfillHandlers;
  private readonly _latest;
  private readonly _backfill;
  private readonly _clients;
  private readonly _clientsListeners;
  private readonly _commandRejectedListeners;
  private _cleanup;
  private _heartbeatTimer;
  private _staleTimer;
  constructor(transport: IDevtoolsTransport);
  /** Every client this window has heard from, newest-labelled-first is not guaranteed — sort in the UI. */
  getClients(): IDevtoolsClientInfo[];
  start(): void;
  stop(): void;
  /** Announce presence — hosts (re)attach + replay, and it doubles as our heartbeat. */
  hello(): void;
  onClients(listener: (clients: IDevtoolsClientInfo[]) => void): () => void;
  onSnapshot(clientId: string, scope: string, handler: (snapshot: unknown) => void): () => void;
  onSample(clientId: string, scope: string, handler: (sample: ITrafficSample) => void): () => void;
  /** Seed a mirror core from a client's backfill (replays the last one if it already arrived). */
  onBackfill(clientId: string, scope: string, handler: (state: unknown) => void): () => void;
  /** Observe a sample-scope across ALL clients (for a merged "all clients" traffic core). */
  onAnySample(scope: string, handler: (sample: ITrafficSample) => void): () => void;
  sendCommand(clientId: string, scope: string, command: unknown): void;
  /**
   * Observe commands this window sent that a producer **refused** — today, a producer that is
   * read-only to remote windows (`allowRemoteCommands: false`, the default). Fires only for this
   * window's own commands.
   *
   * Worth wiring even where the UI already disables the controls: the disabled state is inferred
   * from what a producer *says* it allows, while this is what it actually *did*. If those two ever
   * disagree, the operator should hear it from the producer rather than trust the greyed-out button.
   */
  onCommandRejected(listener: (rejection: IDevtoolsCommandRejection) => void): () => void;
  /**
   * Tell ONE client the accent colour the window has assigned it — the hue of the lane it is shown
   * in — or `null` to clear it. Fire-and-forget: a host that starts later re-learns its accent the
   * next time the window reconciles (on a client-list or selection change), and a host that ignores
   * the message loses only the cosmetic chip tint.
   */
  setAccent(clientId: string, color: string | null): void;
  private readonly _onFocus;
  /** Only the visible edge matters — going hidden needs no announcement, and posts nothing. */
  private readonly _onVisibilityChange;
  private _onMessage;
  private _touchClient;
  private _sweepStale;
  private _notifyClients;
}
/**
 * A `TrafficMetricsCore` on the window side fed one client's forwarded samples
 * for `scope` (full window-select fidelity, unlike a single windowed snapshot).
 */
//#endregion
//#region src/devtools/core/ActionDevtools.types.d.ts
type TDevtoolsActionStatus = "running" | "success" | "action-error" | "failed" | "aborted";
interface IDevtoolsRouteItem {
  runtime: IRuntimeCoordinate;
  handlerType: "local" | "peer";
  handlerClient?: {
    envId: string;
    perId?: string;
    insId?: string;
  };
  /** Transport type string (e.g. "http", "ws", "custom"). */
  transport?: string;
  /** Short transport summary for chips (e.g. "POST /resolve_action"). */
  transportSummary?: string;
  /** Resolved endpoint (request URL / WebSocket URL), when available. */
  transportUrl?: string;
  time: number;
  label?: string;
}
interface IDevtoolsActionMeta {
  timeCreated: number;
  originClient: {
    envId: string;
    perId?: string;
    insId?: string;
  };
  routing: IDevtoolsRouteItem[];
}
/** Reliable-delivery facts for a `.reliable()` action row: the tier + this frame's per-stream seq. */
interface IDevtoolsActionReliability {
  /** `"session"` | `"persisted"` (the {@link EReliabilityTier} value). */
  tier: string;
  /** This frame's sequence number in its stream. */
  seq?: number;
  /** The `streamKey` the send rode on, when the stream is keyed. */
  streamKey?: string;
  /** `true` once the peer's cumulative ack covered this frame — the sender-side proof of delivery. */
  acked?: boolean;
}
interface IDevtoolsActionEntry {
  cuid: string;
  actionId: string;
  domain: string;
  allDomains: string[];
  status: TDevtoolsActionStatus;
  startTime: number;
  endTime?: number;
  input: unknown;
  inputHash?: string;
  output?: unknown;
  outputHash?: string;
  error?: unknown;
  /**
   * For an `action-error`: did the action declare this error via `.throws()`?
   * `true` → expected, per-action error; `false` → undeclared / unhandled.
   */
  expected?: boolean;
  abortReason?: unknown;
  progressUpdates: TActionProgress[];
  meta: IDevtoolsActionMeta;
  parentCuid?: string;
  callSite?: string;
  errorStack?: string;
  /** Present for a `.reliable()` action — its tier + this frame's seq (for a reliable chip on the row). */
  reliability?: IDevtoolsActionReliability;
}
type TDevtoolsListener = (entries: readonly IDevtoolsActionEntry[]) => void;
/**
 * The read/control surface the action panel needs from its core — satisfied by
 * both the live `ActionDevtoolsCore` and the `RemoteActionDevtoolsCore` that
 * mirrors a host over the devtools transport. The panel depends on this, not the
 * concrete class, so a popped-out window can drive the same panel remotely.
 */
interface IActionDevtoolsSource {
  readonly paused: boolean;
  getEntries(): readonly IDevtoolsActionEntry[];
  subscribe(listener: TDevtoolsListener): () => void;
  clear(): void;
  togglePaused(): void;
}
interface IDevtoolsObservableDomain {
  domain: string;
  addActionListener(listener: (update: any) => void): () => void;
}
//#endregion
//#region src/devtools/core/ActionDevtoolsCore.d.ts
interface IActionDevtoolsCoreOptions {
  /** Max root entries to retain. Older entries (and their children) are evicted. */
  maxEntries?: number;
}
declare class ActionDevtoolsCore {
  private _entries;
  private _listeners;
  private readonly _maxEntries;
  private _paused;
  constructor(options?: IActionDevtoolsCoreOptions);
  get paused(): boolean;
  /**
   * While paused, no NEW actions are recorded; actions already on the timeline
   * still settle (progress / reliability / finish updates apply), so nothing is
   * left stuck "running" forever. Mirrors `StateDevtoolsCore.setPaused`.
   */
  setPaused(paused: boolean): void;
  togglePaused(): void;
  attachToDomain(domain: IDevtoolsObservableDomain): () => void;
  getEntries(): readonly IDevtoolsActionEntry[];
  subscribe(listener: TDevtoolsListener): () => void;
  clear(): void;
  private _updateEntry;
  private _notify;
}
//#endregion
export { IDevtoolsObservableDomain as a, DevtoolsWindowClient as c, ITrafficMetricsCoreOptions as d, ITrafficSample as f, TrafficMetricsCore as g, ITrafficWindowTotals as h, IDevtoolsActionEntry as i, IDevtoolsSnapshotScope as l, ITrafficSnapshotQuery as m, IActionDevtoolsCoreOptions as n, TDevtoolsActionStatus as o, ITrafficSnapshot as p, IActionDevtoolsSource as r, TDevtoolsListener as s, ActionDevtoolsCore as t, ITrafficLaneStats as u };
//# sourceMappingURL=ActionDevtoolsCore-DM3F2IXJ.d.mts.map