@nice-code/action 0.18.0 → 0.20.0

package/build/{ActionPayload.types-snDlSIF-.d.cts → ActionPayload.types-D0DM-g65.d.mts}

@@ -1,8 +1,8 @@
 import { INiceErrorDomainProps, InferNiceError, NiceError, NiceErrorDomain, err_cast_not_nice } from "@nice-code/error";
-import { StandardSchemaV1 } from "@standard-schema/spec";
 import { RuntimeName } from "std-env";
 import { ClientCryptoKeyLink, StorageAdapter, TSerializedCryptoKeyData_Ed25519_Raw, TSerializedCryptoKeyData_X25519_Raw, TTypeAndId } from "@nice-code/util";
 import * as v from "valibot";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/ActionDefinition/Schema/ActionSchema.types.d.ts
 type TTransportedValue<RAW_VAL, SERDE_VAL> = [RAW_VAL] | [RAW_VAL, SERDE_VAL];
@@ -1027,6 +1027,13 @@ declare abstract class TransportConnection<T extends ETransportShape = ETranspor
   protected _finalizeReady(readyData: RD): IActionTransportReadyData_Methods | Promise<IActionTransportReadyData_Methods>;
   protected _getCacheKey(input: RP): string | null;
   getCacheKey(input: RP): string | null;
+  /**
+   * Whether this transport can serve the given action right now. Consulted by the manager before
+   * cache-key resolution and `getTransport`; a `false` result skips this transport (treated as
+   * `unsupported`) and the manager falls through to the next in preference order. Defaults to `true`
+   * when the transport declares no gate.
+   */
+  isAvailable(input: RP): boolean;
   getTransport(input: RP): TTransportStatusInfo<IActionTransportReadyData_Methods>;
   protected _processTransportStatus(input: RP): TTransportStatusInfo<IActionTransportReadyData_Methods>;
   /** Await carrier readiness, then finalize (possibly running a handshake) into the live methods. */
@@ -1174,6 +1181,15 @@ interface IActionTransportResolvers {
 type TGetTransportFn<IN extends ITransportRouteActionParams, READY extends IActionTransportReadyData_Base> = (input: IN) => TTransportStatusInfo_GetTransport_Output<READY>;
 interface IActionTransportInitialized<IN extends ITransportRouteActionParams, READY extends IActionTransportReadyData_Base> {
   getTransportCacheKey?: (input: IN) => string[];
+  /**
+   * Optional availability gate, consulted by {@link ConnectionTransportManager} *before* cache-key
+   * resolution and `getTransport`. When it returns `false`, this transport is treated as `unsupported`
+   * for that action and the manager falls through to the next transport in preference order — without
+   * opening the carrier or computing its cache key. Re-evaluated per action dispatch, so a transport can
+   * become available later (e.g. once a session/connection precondition is met) with no reconnect. Omit =
+   * always available.
+   */
+  isAvailable?: (input: IN) => boolean;
   getTransport: TGetTransportFn<IN, READY>;
 }
 interface IActionTransportDef<TYPE extends ETransportShape, INIT extends IActionTransportInitialized<any, any>> {
@@ -1862,6 +1878,88 @@ interface IAcceptChannelOptions<TConn> {
  */
 declare function acceptChannel<TO_ACCEPTOR extends readonly ActionDomain<any>[], TO_CONNECTOR extends readonly ActionDomain<any>[], TConn = unknown>(runtime: ActionRuntime, channel: ISecureChannel<TO_ACCEPTOR, TO_CONNECTOR>, options: IAcceptChannelOptions<TConn>): AcceptorHandler<TConn>;
 //#endregion
+//#region src/ActionRuntime/Handler/PeerLink/Acceptor/Hibernation/ConnectionStateStore.d.ts
+/**
+ * The composite value persisted to a connection's attachment: the consumer's own app state plus the
+ * {@link AcceptorHandler} routing binding. Co-storing them in one slot means a transport whose
+ * sockets outlive process eviction (e.g. a Durable Object's hibernatable WebSocket) recovers both the
+ * application identity *and* the action routing from a single attachment after a wake — no storage reads.
+ */
+interface IConnectionAttachment<TApp> {
+  app?: TApp;
+  binding?: IAcceptorConnectionBinding;
+}
+interface IConnectionStateStoreOptions<TConn, TApp> {
+  /** Read a connection's raw attachment (e.g. `(ws) => ws.deserializeAttachment()`). */
+  read: (connection: TConn) => unknown;
+  /** Persist a connection's attachment (e.g. `(ws, value) => ws.serializeAttachment(value)`). */
+  write: (connection: TConn, value: IConnectionAttachment<TApp>) => void;
+  /**
+   * All currently-live connections (e.g. `() => ctx.getWebSockets()`). Used to replay routing bindings
+   * after a wake (via {@link createConnectionStateStore}) and to enumerate app state in
+   * {@link ConnectionStateStore.entries}.
+   */
+  getConnections: () => TConn[];
+  /**
+   * Optional Standard Schema (valibot, zod, …) validating the *app* portion on read. A value that
+   * fails validation reads back as `null` — the same lenient behavior as a hand-written safeParse
+   * helper. The binding is the library's own shape and is never validated.
+   */
+  schema?: StandardSchemaV1<unknown, TApp>;
+}
+/**
+ * A typed per-connection state store that co-owns the app state and the acceptor handler's routing
+ * binding in one attachment, so neither the consumer nor the handler has to hand-merge the two. Create
+ * it through {@link createConnectionStateStore} (which also wires binding persistence and replays
+ * surviving connections after a wake), then `get`/`set`/`clearApp` the app state directly.
+ *
+ * The mechanism is carrier-neutral — it only needs read/write/enumerate callbacks for the connection's
+ * attachment — but it pays off on transports whose connections outlive process eviction (e.g. a
+ * Durable Object's hibernatable WebSockets), which is why it lives beside the hibernation adapter.
+ *
+ * ```ts
+ * const players = createConnectionStateStore(serverHandler, {
+ *   schema: vs_player,
+ *   read: (ws) => ws.deserializeAttachment(),
+ *   write: (ws, v) => ws.serializeAttachment(v),
+ *   getConnections: () => ctx.getWebSockets(),
+ * });
+ * players.set(ws, player); // binding is preserved automatically
+ * const player = players.get(ws);
+ * ```
+ */
+declare class ConnectionStateStore<TConn, TApp> {
+  private readonly options;
+  constructor(options: IConnectionStateStoreOptions<TConn, TApp>);
+  /** The validated app state for a connection, or `null` if unset / invalid. */
+  get(connection: TConn): TApp | null;
+  /** Set the app state, preserving the runtime binding already pinned to the connection. */
+  set(connection: TConn, app: TApp): void;
+  /** Clear the app state but keep the binding (e.g. a spectator that stopped watching). */
+  clearApp(connection: TConn): void;
+  /** Every live connection paired with its (validated) app state — for rebuilding in-memory state after a wake. */
+  entries(): [TConn, TApp | null][];
+  /** @internal Persist a freshly-bound connection's binding, preserving any app state already stored. */
+  _persistBinding(connection: TConn, binding: IAcceptorConnectionBinding): void;
+  /** @internal The persisted binding for a connection, if any (used to replay routing after a wake). */
+  _readBinding(connection: TConn): IAcceptorConnectionBinding | undefined;
+  private _readAttachment;
+  private _validateApp;
+}
+/**
+ * Build a per-connection {@link ConnectionStateStore} bound to an {@link AcceptorHandler}: it registers
+ * itself as the handler's connection-bound persistence callback (so bindings are written without
+ * overwriting app state) and immediately replays every live connection's stored binding via
+ * {@link AcceptorHandler.rehydrateConnection} — so on a transport that resumes after eviction (e.g. a
+ * Durable Object waking from hibernation) both the app identity and the action routing come back from a
+ * single attachment, with no storage reads and no hand-rolled merge.
+ *
+ * Lives outside the handler so the generic {@link AcceptorHandler} stays free of any attachment/
+ * hibernation concern — it exposes only the neutral `setOnConnectionBound` + `rehydrateConnection`
+ * hooks this builder drives.
+ */
+declare function createConnectionStateStore<TConn, TApp>(handler: AcceptorHandler<TConn>, options: IConnectionStateStoreOptions<TConn, TApp>): ConnectionStateStore<TConn, TApp>;
+//#endregion
 //#region src/ActionRuntime/Handler/PeerLink/Acceptor/Hibernation/createHibernatableWsServerAdapter.d.ts
 interface IHibernatableWsServerAdapterOptions<TConn> {
   /** The handler to drive (from `createSecureAcceptorHandler` or `createAcceptorHandler`). */
@@ -2013,17 +2111,21 @@ interface IExchangeCarrierSource {
  *   upgrade.
  */
 /**
- * Persistence + replay hooks for a duplex carrier whose connections outlive process eviction (e.g. a
- * Durable Object's hibernatable WebSockets). Optional — omit for a transport that never hibernates. The
- * same surface {@link createHibernatableWsServerAdapter} consumes, minus the handler it's bound to.
+ * Raw read/write access to a connection's persisted attachment, for a duplex carrier whose connections
+ * outlive process eviction (e.g. a Durable Object's hibernatable WebSockets). Optional — omit for a
+ * transport that never hibernates (per-connection state is then in-memory only).
+ *
+ * `serveChannel` owns the attachment *layout*: it co-stores the routing binding and (when
+ * `connectionState` is requested) per-connection app state as one composite in this single slot, so both
+ * survive a wake. The carrier only has to say how to read/write the slot and enumerate live connections.
  */
-interface IAcceptorHibernation<TConn> {
-  /** All currently-live connections — replayed on build to rebuild bindings after a wake. */
+interface IAcceptorAttachmentStore<TConn> {
+  /** All currently-live connections — enumerated on build to replay binding + app state after a wake. */
   getConnections: () => TConn[];
-  /** Read a connection's persisted binding (e.g. `(ws) => ws.deserializeAttachment()`). */
-  getAttachment: (connection: TConn) => IAcceptorConnectionBinding | undefined;
-  /** Persist a connection's binding when it is bound (e.g. `(ws, b) => ws.serializeAttachment(b)`). */
-  setAttachment: (connection: TConn, binding: IAcceptorConnectionBinding) => void;
+  /** Read a connection's persisted attachment (e.g. `(ws) => ws.deserializeAttachment()`). */
+  read: (connection: TConn) => unknown;
+  /** Persist a connection's attachment (e.g. `(ws, value) => ws.serializeAttachment(value)`). */
+  write: (connection: TConn, value: unknown) => void;
 }
 /**
  * A duplex carrier is also its own lifecycle handle: once it has been passed to `serveChannel`, feed each
@@ -2070,8 +2172,12 @@ interface IDuplexAcceptorCarrier<TConn = unknown> extends IDuplexCarrierLifecycl
    * Only consulted when {@link upgrade} is present.
    */
   isUpgrade?: (request: Request, url: URL) => boolean;
-  /** Optional persistence + replay for connections that survive eviction (Durable Object hibernation). */
-  hibernation?: IAcceptorHibernation<TConn>;
+  /**
+   * Optional attachment read/write for connections that survive eviction (Durable Object hibernation).
+   * Present → `serveChannel` persists the routing binding (and any `connectionState`) here and replays it
+   * on wake. Absent → per-connection state is in-memory only.
+   */
+  attachmentStore?: IAcceptorAttachmentStore<TConn>;
   /** Short carrier-kind label for the devtools chip (e.g. `"ws"`, `"webrtc"`). */
   readonly carrierLabel: string;
 }
@@ -2113,7 +2219,15 @@ type TAcceptorCarrier<TConn = unknown> = IDuplexAcceptorCarrier<TConn> | IExchan
 declare function isExchangeAcceptorCarrier<TConn>(carrier: TAcceptorCarrier<TConn>): carrier is IExchangeAcceptorCarrier;
 //#endregion
 //#region src/ActionRuntime/Channel/serveChannel.d.ts
-interface IServeChannelOptions<TConn> {
+/** Per-connection app-state config for {@link serveChannel}'s `connectionState`. */
+interface IServeConnectionStateOptions<TApp> {
+  /**
+   * Optional Standard Schema (valibot, zod, …) validating the app state on read — a value that fails
+   * validation reads back as `null`. Omit to store the app state untyped.
+   */
+  schema?: StandardSchemaV1<unknown, TApp>;
+}
+interface IServeChannelOptions<TO_ACCEPTOR extends readonly ActionDomain<any>[], TConn, TApp = unknown> {
   /**
    * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
    * used to score return-path dispatch back to the right connection.
@@ -2150,12 +2264,25 @@ interface IServeChannelOptions<TConn> {
   verifyKeyResolver?: IClientVerifyKeyResolver;
   /** Timeout (ms) applied to server-initiated actions awaiting a client response. */
   defaultTimeout?: number;
+  /**
+   * Co-store per-connection app state alongside the routing binding in the sole duplex carrier's connection
+   * attachment, so both survive a wake from eviction. Reach the typed store back on `server.connections`.
+   * Requires the carrier to expose an attachment store (the Cloudflare `durableObjectWsCarrier` does) and
+   * exactly one duplex carrier.
+   */
+  connectionState?: IServeConnectionStateOptions<TApp>;
+  /**
+   * Connection-aware action cases for the channel's acceptor (`toAcceptor`) domains — each case receives the
+   * primed request *and* the originating connection (the connection-aware dual of `handlers`). Registered on
+   * the runtime for you. Requires exactly one duplex carrier.
+   */
+  channelCases?: TChannelAcceptorCases<TO_ACCEPTOR, TConn>;
 }
 /**
  * One server serving a secure channel over several carriers — the accept-in dual of `connectChannel`,
  * returned by {@link serveChannel}. Wire its surface straight to the host's request/socket events.
  */
-interface IChannelServer<TConn> {
+interface IChannelServer<TConn, TApp = unknown> {
   /**
    * The duplex acceptor handlers — one per duplex carrier, in carrier order (empty if none). For pushing,
    * prefer {@link pushToClient} (it resolves the owning handler); reach for these for cross-carrier work
@@ -2181,6 +2308,23 @@ interface IChannelServer<TConn> {
   pushToClient: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(target: TConn | RuntimeCoordinate, request: ActionPayload_Request<DOM, ID>, options?: {
     timeout?: number;
   }) => RunningAction<DOM, ID>;
+  /**
+   * Fan a server-initiated action out to every connection on the sole duplex carrier (skip the origin with
+   * `except`, filter with `where`). The push-to-many counterpart of {@link pushToClient}. Throws if there
+   * isn't exactly one duplex carrier (with several, broadcast over a specific `handlers[i]`).
+   */
+  broadcast: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(makeRequest: () => ActionPayload_Request<DOM, ID>, options?: {
+    except?: TConn | null;
+    where?: (connection: TConn) => boolean;
+    timeout?: number;
+    onError?: (error: unknown, connection: TConn) => void;
+  }) => void;
+  /**
+   * The per-connection app-state store co-stored with the routing binding in the connection attachment —
+   * present only when `connectionState` was passed. `get`/`set`/`clearApp`/`entries` it directly; it
+   * survives hibernation alongside the binding.
+   */
+  connections?: ConnectionStateStore<TConn, TApp>;
 }
 /**
  * Serve a secure channel over one or more carriers from a single call — the accept-in dual of
@@ -2188,24 +2332,33 @@ interface IChannelServer<TConn> {
  * resolver) and the security block (coordinate, dictionary version, accepted levels) *once* from
  * `(runtime, channel)` and fans them across every carrier, so the WebSocket and the secure-HTTP endpoint
  * can never drift apart. It registers your handlers (plus the duplex acceptor it builds) on the runtime,
- * wires hibernation when the duplex carrier declares it, and returns a single {@link IChannelServer} whose
- * `fetch` / `duplex` / `pushToClient` you forward straight to the host:
+ * wires hibernation when the duplex carrier exposes an attachment store, and returns a single
+ * {@link IChannelServer} whose `fetch` / `duplex` / `pushToClient` / `broadcast` you forward straight to
+ * the host:
  * ```ts
  * const server = serveChannel(runtime, channel, {
  *   clientEnv, storage,
- *   carriers: [wsAcceptorCarrier({ send, upgrade, hibernation }), httpAcceptorCarrier()],
- *   handlers: [localHandler],
+ *   carriers: [wsAcceptorCarrier({ send, upgrade, attachmentStore }), httpAcceptorCarrier()],
+ *   connectionState: { schema: vs_player }, // optional: co-store per-connection app state (survives hibernation)
+ *   channelCases: { join: (action, conn) => { … } }, // optional: connection-aware action cases
  * });
  * // fetch(req) => server.fetch(req)
  * // webSocketMessage(conn, m) => server.duplex?.receive(conn, m)
  * // webSocketClose/Error(conn) => server.duplex?.drop(conn)
+ * // server.connections.get(conn) / server.broadcast(() => push.request(…), { except: conn })
  * ```
  *
  * `TConn` (the live-connection token a duplex carrier hands back through `send`/`receive`/`drop`) is
  * inferred from the carriers — `WebSocket` for `wsAcceptorCarrier`, the data-channel type for a WebRTC
- * carrier, and so on — so it stays carrier-agnostic.
+ * carrier, and so on — so it stays carrier-agnostic. Passing `connectionState` narrows the return so
+ * `server.connections` is non-optional.
  */
-declare function serveChannel<TO_ACCEPTOR extends readonly ActionDomain<any>[] = readonly ActionDomain<any>[], TO_CONNECTOR extends readonly ActionDomain<any>[] = readonly ActionDomain<any>[], TConn = unknown>(runtime: ActionRuntime, channel: ISecureChannel<TO_ACCEPTOR, TO_CONNECTOR>, options: IServeChannelOptions<TConn>): IChannelServer<TConn>;
+declare function serveChannel<TO_ACCEPTOR extends readonly ActionDomain<any>[], TO_CONNECTOR extends readonly ActionDomain<any>[], TConn, TApp>(runtime: ActionRuntime, channel: ISecureChannel<TO_ACCEPTOR, TO_CONNECTOR>, options: IServeChannelOptions<TO_ACCEPTOR, TConn, TApp> & {
+  connectionState: IServeConnectionStateOptions<TApp>;
+}): IChannelServer<TConn, TApp> & {
+  connections: ConnectionStateStore<TConn, TApp>;
+};
+declare function serveChannel<TO_ACCEPTOR extends readonly ActionDomain<any>[] = readonly ActionDomain<any>[], TO_CONNECTOR extends readonly ActionDomain<any>[] = readonly ActionDomain<any>[], TConn = unknown, TApp = unknown>(runtime: ActionRuntime, channel: ISecureChannel<TO_ACCEPTOR, TO_CONNECTOR>, options: IServeChannelOptions<TO_ACCEPTOR, TConn, TApp>): IChannelServer<TConn, TApp>;
 //#endregion
 //#region src/ActionRuntime/Transport/SecureSession/exchangeAcceptor.d.ts
 /** Acceptor secure config for the exchange (HTTP) endpoint — same identity an `AcceptorHandler` uses. */
@@ -2352,88 +2505,6 @@ interface ISecureAcceptorHandlerOptions<TConn> {
  */
 declare function createSecureAcceptorHandler<TConn = unknown>(options: ISecureAcceptorHandlerOptions<TConn>): AcceptorHandler<TConn>;
 //#endregion
-//#region src/ActionRuntime/Handler/PeerLink/Acceptor/Hibernation/ConnectionStateStore.d.ts
-/**
- * The composite value persisted to a connection's attachment: the consumer's own app state plus the
- * {@link AcceptorHandler} routing binding. Co-storing them in one slot means a transport whose
- * sockets outlive process eviction (e.g. a Durable Object's hibernatable WebSocket) recovers both the
- * application identity *and* the action routing from a single attachment after a wake — no storage reads.
- */
-interface IConnectionAttachment<TApp> {
-  app?: TApp;
-  binding?: IAcceptorConnectionBinding;
-}
-interface IConnectionStateStoreOptions<TConn, TApp> {
-  /** Read a connection's raw attachment (e.g. `(ws) => ws.deserializeAttachment()`). */
-  read: (connection: TConn) => unknown;
-  /** Persist a connection's attachment (e.g. `(ws, value) => ws.serializeAttachment(value)`). */
-  write: (connection: TConn, value: IConnectionAttachment<TApp>) => void;
-  /**
-   * All currently-live connections (e.g. `() => ctx.getWebSockets()`). Used to replay routing bindings
-   * after a wake (via {@link createConnectionStateStore}) and to enumerate app state in
-   * {@link ConnectionStateStore.entries}.
-   */
-  getConnections: () => TConn[];
-  /**
-   * Optional Standard Schema (valibot, zod, …) validating the *app* portion on read. A value that
-   * fails validation reads back as `null` — the same lenient behavior as a hand-written safeParse
-   * helper. The binding is the library's own shape and is never validated.
-   */
-  schema?: StandardSchemaV1<unknown, TApp>;
-}
-/**
- * A typed per-connection state store that co-owns the app state and the acceptor handler's routing
- * binding in one attachment, so neither the consumer nor the handler has to hand-merge the two. Create
- * it through {@link createConnectionStateStore} (which also wires binding persistence and replays
- * surviving connections after a wake), then `get`/`set`/`clearApp` the app state directly.
- *
- * The mechanism is carrier-neutral — it only needs read/write/enumerate callbacks for the connection's
- * attachment — but it pays off on transports whose connections outlive process eviction (e.g. a
- * Durable Object's hibernatable WebSockets), which is why it lives beside the hibernation adapter.
- *
- * ```ts
- * const players = createConnectionStateStore(serverHandler, {
- *   schema: vs_player,
- *   read: (ws) => ws.deserializeAttachment(),
- *   write: (ws, v) => ws.serializeAttachment(v),
- *   getConnections: () => ctx.getWebSockets(),
- * });
- * players.set(ws, player); // binding is preserved automatically
- * const player = players.get(ws);
- * ```
- */
-declare class ConnectionStateStore<TConn, TApp> {
-  private readonly options;
-  constructor(options: IConnectionStateStoreOptions<TConn, TApp>);
-  /** The validated app state for a connection, or `null` if unset / invalid. */
-  get(connection: TConn): TApp | null;
-  /** Set the app state, preserving the runtime binding already pinned to the connection. */
-  set(connection: TConn, app: TApp): void;
-  /** Clear the app state but keep the binding (e.g. a spectator that stopped watching). */
-  clearApp(connection: TConn): void;
-  /** Every live connection paired with its (validated) app state — for rebuilding in-memory state after a wake. */
-  entries(): [TConn, TApp | null][];
-  /** @internal Persist a freshly-bound connection's binding, preserving any app state already stored. */
-  _persistBinding(connection: TConn, binding: IAcceptorConnectionBinding): void;
-  /** @internal The persisted binding for a connection, if any (used to replay routing after a wake). */
-  _readBinding(connection: TConn): IAcceptorConnectionBinding | undefined;
-  private _readAttachment;
-  private _validateApp;
-}
-/**
- * Build a per-connection {@link ConnectionStateStore} bound to an {@link AcceptorHandler}: it registers
- * itself as the handler's connection-bound persistence callback (so bindings are written without
- * overwriting app state) and immediately replays every live connection's stored binding via
- * {@link AcceptorHandler.rehydrateConnection} — so on a transport that resumes after eviction (e.g. a
- * Durable Object waking from hibernation) both the app identity and the action routing come back from a
- * single attachment, with no storage reads and no hand-rolled merge.
- *
- * Lives outside the handler so the generic {@link AcceptorHandler} stays free of any attachment/
- * hibernation concern — it exposes only the neutral `setOnConnectionBound` + `rehydrateConnection`
- * hooks this builder drives.
- */
-declare function createConnectionStateStore<TConn, TApp>(handler: AcceptorHandler<TConn>, options: IConnectionStateStoreOptions<TConn, TApp>): ConnectionStateStore<TConn, TApp>;
-//#endregion
 //#region src/ActionRuntime/Handler/PeerLink/Connector/err_nice_external_client.d.ts
 declare const err_nice_external_client: import("@nice-code/error").NiceErrorDomain<{
   domain: string;
@@ -2559,8 +2630,8 @@ interface IWsAcceptorCarrierOptions<TConn> {
   upgrade?: (request: Request, url: URL) => Response | Promise<Response>;
   /** Whether an inbound request is a WS upgrade. Defaults to an `Upgrade: websocket` header. */
   isUpgrade?: (request: Request, url: URL) => boolean;
-  /** Persistence + replay hooks for hibernatable sockets (e.g. a Durable Object). */
-  hibernation?: IAcceptorHibernation<TConn>;
+  /** Attachment read/write for hibernatable sockets (e.g. a Durable Object); `serveChannel` persists here. */
+  attachmentStore?: IAcceptorAttachmentStore<TConn>;
   /** Override the devtools carrier-kind label (defaults to `"ws"`). */
   carrierLabel?: string;
 }
@@ -2735,6 +2806,12 @@ interface IExchangeTransportOptions {
   updateRunConfig?: TUpdateActionRunConfig;
   /** Keys identifying a reusable session, so one carrier is shared across actions to the same peer. */
   getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+  /**
+   * Optional availability gate. When it returns `false`, the manager skips this transport for that action
+   * (reporting `unsupported`) and falls through to the next — without opening the carrier or computing its
+   * cache key. Re-evaluated per dispatch, so the transport can become available later with no reconnect.
+   */
+  available?: (input: ITransportRouteActionParams) => boolean;
   /** Short label for the devtools chip (defaults to "exchange"). */
   label?: string;
   getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
@@ -2841,6 +2918,12 @@ interface ILinkTransportOptions {
   updateRunConfig?: TUpdateActionRunConfig;
   /** Keys identifying a reusable channel, so one carrier is shared across actions to the same peer. */
   getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+  /**
+   * Optional availability gate. When it returns `false`, the manager skips this transport for that action
+   * (reporting `unsupported`) and falls through to the next — without opening the carrier or computing its
+   * cache key. Re-evaluated per dispatch, so the transport can become available later with no reconnect.
+   */
+  available?: (input: ITransportRouteActionParams) => boolean;
   /** Short label for the devtools chip (defaults to "link"). */
   label?: string;
   getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
@@ -2875,6 +2958,13 @@ interface IPlainTransportOptions {
   formatMessage?: TLinkFormatMessage;
   /** Per-channel codec factory for stateful duplex codecs (e.g. the binary session). */
   createFormatMessage?: () => TLinkFormatMessage;
+  /**
+   * Optional availability gate. When it returns `false`, this transport reports as `unsupported` for that
+   * action and the manager falls through to the next transport in preference order — without opening the
+   * carrier or computing its cache key. Re-evaluated per dispatch, so a transport can become available
+   * later (e.g. once a session/connection precondition holds) with no reconnect. Omit = always available.
+   */
+  available?: (input: ITransportRouteActionParams) => boolean;
   updateRunConfig?: TUpdateActionRunConfig;
   /** Override the devtools chip label (defaults to the carrier's `carrierLabel`). */
   label?: string;
@@ -2894,6 +2984,55 @@ declare function plainTransport(options: IPlainTransportOptions & {
   carrier: IDuplexCarrierSource;
 }): LinkTransport;
 //#endregion
+//#region src/ActionRuntime/Transport/SecureSession/exchangeProtocol.d.ts
+/**
+ * The application-level envelope for secure action traffic over an {@link IExchangeCarrier} (HTTP). An
+ * exchange carrier only moves one request frame → one reply frame with no unsolicited push, so the
+ * handshake and the per-action token + crypto all ride in this envelope (a JSON string body) rather than
+ * on a persistent channel. The three security levels share it:
+ *
+ * - `none` — no handshake, no token: an `act` envelope carries the plaintext wire both ways.
+ * - `authenticated` — a one-time handshake yields a session `token`; each later `act` carries it +
+ *   the plaintext wire.
+ * - `encrypted` — same, but the wire is AES-GCM ciphertext, base64 in the `c` field.
+ *
+ * The handshake runs as two `hs` exchanges (hello→welcome, prove→accept) correlated by a client-chosen
+ * `hsid`, since stateless requests can't rely on channel ordering. The `accept` reply carries the token.
+ */
+type TWireJson = TActionPayload_Any_JsonObject<any, any>;
+/** Connector → acceptor request envelope. */
+type TExchangeRequest = {
+  k: "hs";
+  hsid: string;
+  m: string;
+} | {
+  k: "act";
+  t?: string;
+  w: TWireJson;
+} | {
+  k: "act";
+  t?: string;
+  c: string;
+};
+/** Acceptor → connector reply envelope. */
+type TExchangeReply = {
+  k: "hs";
+  m: string;
+  t?: string;
+} | {
+  k: "act";
+  w: TWireJson;
+} | {
+  k: "act";
+  c: string;
+} | {
+  k: "err";
+  message: string;
+};
+declare function encodeExchange(envelope: TExchangeRequest | TExchangeReply): string;
+declare function decodeExchangeRequest(raw: string): TExchangeRequest | undefined;
+declare function decodeExchangeReply(raw: string): TExchangeReply | undefined;
+//#endregion
 //#region src/ActionRuntime/Transport/secureTransport.d.ts
 interface ISecureTransportOptions {
   /** The shared channel identity (per-connection codec + dictionary version) — same one both ends use. */
@@ -2904,6 +3043,13 @@ interface ISecureTransportOptions {
   storageAdapter: StorageAdapter;
   /** The level this client requests; the peer must allow it. */
   securityLevel: ESecurityLevel;
+  /**
+   * Optional availability gate. When it returns `false`, this transport reports as `unsupported` for that
+   * action and the manager falls through to the next transport in preference order — without opening the
+   * carrier or computing its cache key. Re-evaluated per dispatch, so a transport can become available
+   * later (e.g. once a session/connection precondition holds) with no reconnect. Omit = always available.
+   */
+  available?: (input: ITransportRouteActionParams) => boolean;
   /**
    * How to reach the peer. A duplex carrier (`wsCarrier(url)`, `rtcCarrier(dc)`,
    * `inMemoryCarrier().carrier`) runs the push-capable session; an exchange carrier (`httpCarrier(...)`)
@@ -3151,5 +3297,5 @@ interface IActionPayload_Result_JsonObject<DOM extends IActionDomain = IActionDo
 type TActionPayload_Any_Instance<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = ActionPayload_Request<DOM, ID> | ActionPayload_Result<DOM, ID> | ActionPayload_Progress<DOM, ID>;
 type TActionPayload_Any_JsonObject<DOM extends IActionDomain = IActionDomain, ID extends keyof DOM["actionSchema"] & string = keyof DOM["actionSchema"] & string> = IActionPayload_Request_JsonObject<DOM, ID> | IActionPayload_Progress_JsonObject<DOM, ID> | IActionPayload_Result_JsonObject<DOM, ID>;
 //#endregion
-export { EErrId_NiceTransport_WebSocket as $, IClientVerifyKeyResolver as $n, TTransportedValue as $r, IAcceptorConnectionBinding as $t, ILinkTransportOptions as A, ITransportStatusInfo_Ready as An, ActionPayload_Result as Ar, IDuplexCarrier as At, IActionFrameCryptoConfig as B, TSendActionDataMethod as Bn, TActionDomainChildDef as Br, IActionChannel as Bt, decodeActionFrame as C, ITransportMethod_SendActionData_Input as Cn, IRunningActionUpdate_Abort as Cr, IServeChannelOptions as Ct, secureTransport as D, ITransportStatusInfo_Base as Dn, TRunningActionUpdate as Dr, IExchangeAcceptorCarrier as Dt, ISecureTransportOptions as E, ITransportRouteInfo as En, IRunningActionUpdate_Success as Er, IDuplexAcceptorCarrier as Et, err_nice_transport as F, TOnResolveAnyIncomingActionData_Json as Fn, TRuntimeCoordinateEnvId as Fr, TFrame$1 as Ft, TCarrierFetch as G, TTransportStatusInfo_GetTransport_Output as Gn, TPossibleDomainId as Gr, acceptChannelConnections as Gt, createBinaryWireAdapter as H, TTransportCache as Hn, TDomainActionId as Hr, TChannelAcceptorCases as Ht, ExchangeTransport as I, TOnResolveIncomingRequest as In, TRuntimeCoordinateStringId as Ir, IDuplexConnectionRouter as It, httpAcceptorCarrier as J, Transport as Jn, EActionResponseMode as Jr, ISecureChannel as Jt, httpCarrier as K, TUpdateActionRunConfig as Kn, TPossibleDomainIdList as Kr, connectChannel as Kt, IExchangeTransportOptions as L, TOnResolveIncomingRequestJson as Ln, IActionDomain as Lr, IHibernatableWsServerAdapterOptions as Lt, IActionTransportReadyData_Link as M, IUpdateActionRunConfig_Output as Mn, IRuntimeCoordinateSpecifics as Mr, IExchangeCarrier as Mt, TLinkFormatMessage as N, TGetTransportFn as Nn, IRuntimeFullCoordinates as Nr, IExchangeCarrierSource as Nt, IPlainTransportOptions as O, ITransportStatusInfo_Failed as On, TRunningActionUpdateFinished as Or, TAcceptorCarrier as Ot, EErrId_NiceTransport as P, TOnResolveAnyIncomingActionData as Pn, RuntimeCoordinate as Pr, TCarrier as Pt, wsAcceptorCarrier as Q, IClientVerifyKeyResolveInput as Qn, TActionSerializationDefinition as Qr, AcceptorHandler as Qt, IActionTransportReadyData_Exchange as R, TOnResolveIncomingResponse as Rn, IActionDomainChildOptions as Rr, createHibernatableWsServerAdapter as Rt, IActionFrameDecoder as S, ITransportDispatchAction as Sn, ERunningActionUpdateType as Sr, IChannelServer as St, err_nice_action as T, ITransportRouteClientParams as Tn, IRunningActionUpdate_Started as Tr, IAcceptorHibernation as Tt, IHttpCarrierOptions as U, TTransportInitializationFinishedInfo as Un, TInferInputFromSchema as Ur, TChannelPushHandlers as Ut, createActionFrameCrypto as V, TSendReturnDataMethod as Vn, TActionDomainSchema as Vr, IConnectChannelOptions as Vt, IHttpCarrierRequest as W, TTransportStatusInfo as Wn, TInferOutputFromSchema as Wr, acceptChannel as Wt, wsCarrier as X, ESecurityLevel as Xn, actionSchema as Xr, IBinaryWireSessionOptions as Xt, IWsCarrierOptions as Y, EHandshakeMessageType as Yn, TInferActionError as Yr, defineSecureChannel as Yt, IWsAcceptorCarrierOptions as Z, IClientHandshakeConfig as Zn, TActionSchemaOptions as Zr, createBinaryWireSessionFactory as Zt, TActionProgress as _, IActionTransportReady as _n, ActionPayload_Request as _r, IActionFetchHandlerOptions as _t, IActionPayload_Data_Base as a, IActionWireFormat as an, createInMemoryTofuVerifyKeyResolver as ar, IInMemoryCarrier as at, isActionPayload_Request_JsonObject as b, IActionTransportResolvers as bn, ERunningActionFinishedType as br, IExchangeAcceptorConfig as bt, IActionPayload_Request_JsonObject as c, ActionDomain as cn, decodeHandshakeMessage as cr, IInMemoryServerEndpoint as ct, IActionProgress_Custom as d, ConnectorHandler as dn, PeerLinkHandler as dr, ConnectionStateStore as dt, IAcceptorHandlerOptions as en, IHandshakeEncryptionKeyMaterial as er, err_nice_transport_ws as et, IActionProgress_None as f, createConnectorHandler as fn, ActionLocalHandler as fr, IConnectionAttachment as ft, TActionPayload_Any_JsonObject as g, IActionTransportInitialized as gn, ActionPayload_Progress as gr, createSecureAcceptorHandler as gt, TActionPayload_Any_Instance as h, IActionTransportDef as hn, RunningAction as hr, ISecureAcceptorHandlerOptions as ht, IActionPayload_Base_JsonObject as i, createAcceptorHandler as in, createClientHandshake as ir, rtcDataChannelByteChannel as it, LinkTransport as j, ITransportStatusInfo_Unsupported as jn, IRuntimeCoordinate as jr, IDuplexCarrierSource as jt, plainTransport as k, ITransportStatusInfo_Initializing as kn, TRunningActionUpdateListener as kr, isExchangeAcceptorCarrier as kt, IActionPayload_Result as l, ActionRootDomain as ln, encodeHandshakeMessage as lr, createInMemoryChannelPair as lt, IActionRouteItemHandler as m, ETransportStatus as mn, MaybePromise as mr, createConnectionStateStore as mt, EActionProgressType as n, TActionChannelFormatMessage as nn, IServerHandshakeConfig as nr, rtcCarrier as nt, IActionPayload_Progress as o, createActionRootDomain as on, createServerHandshake as or, inMemoryCarrier as ot, IActionProgress_Percentage as p, ETransportShape as pn, createLocalHandler as pr, IConnectionStateStoreOptions as pt, IHttpAcceptorCarrierOptions as q, ITransportConnectionContext as qn, ActionSchema as qr, defineChannel as qt, IActionPayload_Base as r, TActionConnectionEncoding as rn, THandshakeMessage as rr, IRtcDataChannelLike as rt, IActionPayload_Progress_JsonObject as s, ActionCore as sn, createStorageTofuVerifyKeyResolver as sr, IInMemoryChannelPair as st, EActionPayloadType as t, TAcceptorConnectionCaseFn as tn, IHandshakeResult as tr, IRtcCarrierOptions as tt, IActionPayload_Result_JsonObject as u, ActionRuntime as un, runtimeLinkId as ur, err_nice_external_client as ut, TActionResultOutcome as v, IActionTransportReadyData_Base as vn, IActionCore as vr, createActionFetchHandler as vt, EErrId_NiceAction as w, ITransportRouteActionParams as wn, IRunningActionUpdate_Progress as wr, serveChannel as wt, isActionPayload_Any_JsonObject as x, ISecureClientConfig as xn, ERunningActionState as xr, IExchangeAcceptorSecurity as xt, isActionPayload_Result_JsonObject as y, IActionTransportReadyData_Methods as yn, IActionCore_JsonObject as yr, ExchangeAcceptor as yt, IActionFrameCrypto as z, TOnResolveIncomingResponseJson as zn, IActionRootDomain as zr, IAcceptChannelOptions as zt };
-//# sourceMappingURL=ActionPayload.types-snDlSIF-.d.cts.map
+export { httpAcceptorCarrier as $, ITransportConnectionContext as $n, ActionSchema as $r, defineChannel as $t, decodeExchangeReply as A, ITransportRouteActionParams as An, IRunningActionUpdate_Progress as Ar, TAcceptorCarrier as At, err_nice_transport as B, TOnResolveAnyIncomingActionData as Bn, RuntimeCoordinate as Br, createHibernatableWsServerAdapter as Bt, decodeActionFrame as C, IActionTransportReady as Cn, ActionPayload_Request as Cr, IChannelServer as Ct, secureTransport as D, ISecureClientConfig as Dn, ERunningActionState as Dr, IAcceptorAttachmentStore as Dt, ISecureTransportOptions as E, IActionTransportResolvers as En, ERunningActionFinishedType as Er, serveChannel as Et, ILinkTransportOptions as F, ITransportStatusInfo_Initializing as Fn, TRunningActionUpdateListener as Fr, IExchangeCarrierSource as Ft, IActionFrameCryptoConfig as G, TOnResolveIncomingResponseJson as Gn, IActionRootDomain as Gr, IAcceptChannelOptions as Gt, IExchangeTransportOptions as H, TOnResolveIncomingRequest as Hn, TRuntimeCoordinateStringId as Hr, IConnectionAttachment as Ht, LinkTransport as I, ITransportStatusInfo_Ready as In, ActionPayload_Result as Ir, TCarrier as It, IHttpCarrierOptions as J, TTransportCache as Jn, TDomainActionId as Jr, TChannelAcceptorCases as Jt, createActionFrameCrypto as K, TSendActionDataMethod as Kn, TActionDomainChildDef as Kr, IActionChannel as Kt, IActionTransportReadyData_Link as L, ITransportStatusInfo_Unsupported as Ln, IRuntimeCoordinate as Lr, TFrame$1 as Lt, encodeExchange as M, ITransportRouteInfo as Mn, IRunningActionUpdate_Success as Mr, IDuplexCarrier as Mt, IPlainTransportOptions as N, ITransportStatusInfo_Base as Nn, TRunningActionUpdate as Nr, IDuplexCarrierSource as Nt, TExchangeReply as O, ITransportDispatchAction as On, ERunningActionUpdateType as Or, IDuplexAcceptorCarrier as Ot, plainTransport as P, ITransportStatusInfo_Failed as Pn, TRunningActionUpdateFinished as Pr, IExchangeCarrier as Pt, IHttpAcceptorCarrierOptions as Q, TUpdateActionRunConfig as Qn, TPossibleDomainIdList as Qr, connectChannel as Qt, TLinkFormatMessage as R, IUpdateActionRunConfig_Output as Rn, IRuntimeCoordinateSpecifics as Rr, IDuplexConnectionRouter as Rt, IActionFrameDecoder as S, IActionTransportInitialized as Sn, ActionPayload_Progress as Sr, IExchangeAcceptorSecurity as St, err_nice_action as T, IActionTransportReadyData_Methods as Tn, IActionCore_JsonObject as Tr, IServeConnectionStateOptions as Tt, IActionTransportReadyData_Exchange as U, TOnResolveIncomingRequestJson as Un, IActionDomain as Ur, IConnectionStateStoreOptions as Ut, ExchangeTransport as V, TOnResolveAnyIncomingActionData_Json as Vn, TRuntimeCoordinateEnvId as Vr, ConnectionStateStore as Vt, IActionFrameCrypto as W, TOnResolveIncomingResponse as Wn, IActionDomainChildOptions as Wr, createConnectionStateStore as Wt, TCarrierFetch as X, TTransportStatusInfo as Xn, TInferOutputFromSchema as Xr, acceptChannel as Xt, IHttpCarrierRequest as Y, TTransportInitializationFinishedInfo as Yn, TInferInputFromSchema as Yr, TChannelPushHandlers as Yt, httpCarrier as Z, TTransportStatusInfo_GetTransport_Output as Zn, TPossibleDomainId as Zr, acceptChannelConnections as Zt, TActionProgress as _, ConnectorHandler as _n, PeerLinkHandler as _r, createSecureAcceptorHandler as _t, IActionPayload_Data_Base as a, TTransportedValue as ai, IAcceptorConnectionBinding as an, IClientVerifyKeyResolver as ar, err_nice_transport_ws as at, isActionPayload_Request_JsonObject as b, ETransportStatus as bn, MaybePromise as br, ExchangeAcceptor as bt, IActionPayload_Request_JsonObject as c, TActionChannelFormatMessage as cn, IServerHandshakeConfig as cr, IRtcDataChannelLike as ct, IActionProgress_Custom as d, IActionWireFormat as dn, createInMemoryTofuVerifyKeyResolver as dr, inMemoryCarrier as dt, EActionResponseMode as ei, ISecureChannel as en, Transport as er, IWsCarrierOptions as et, IActionProgress_None as f, createActionRootDomain as fn, createServerHandshake as fr, IInMemoryChannelPair as ft, TActionPayload_Any_JsonObject as g, ActionRuntime as gn, runtimeLinkId as gr, ISecureAcceptorHandlerOptions as gt, TActionPayload_Any_Instance as h, ActionRootDomain as hn, encodeHandshakeMessage as hr, err_nice_external_client as ht, IActionPayload_Base_JsonObject as i, TActionSerializationDefinition as ii, AcceptorHandler as in, IClientVerifyKeyResolveInput as ir, EErrId_NiceTransport_WebSocket as it, decodeExchangeRequest as j, ITransportRouteClientParams as jn, IRunningActionUpdate_Started as jr, isExchangeAcceptorCarrier as jt, TExchangeRequest as k, ITransportMethod_SendActionData_Input as kn, IRunningActionUpdate_Abort as kr, IExchangeAcceptorCarrier as kt, IActionPayload_Result as l, TActionConnectionEncoding as ln, THandshakeMessage as lr, rtcDataChannelByteChannel as lt, IActionRouteItemHandler as m, ActionDomain as mn, decodeHandshakeMessage as mr, createInMemoryChannelPair as mt, EActionProgressType as n, actionSchema as ni, IBinaryWireSessionOptions as nn, ESecurityLevel as nr, IWsAcceptorCarrierOptions as nt, IActionPayload_Progress as o, IAcceptorHandlerOptions as on, IHandshakeEncryptionKeyMaterial as or, IRtcCarrierOptions as ot, IActionProgress_Percentage as p, ActionCore as pn, createStorageTofuVerifyKeyResolver as pr, IInMemoryServerEndpoint as pt, createBinaryWireAdapter as q, TSendReturnDataMethod as qn, TActionDomainSchema as qr, IConnectChannelOptions as qt, IActionPayload_Base as r, TActionSchemaOptions as ri, createBinaryWireSessionFactory as rn, IClientHandshakeConfig as rr, wsAcceptorCarrier as rt, IActionPayload_Progress_JsonObject as s, TAcceptorConnectionCaseFn as sn, IHandshakeResult as sr, rtcCarrier as st, EActionPayloadType as t, TInferActionError as ti, defineSecureChannel as tn, EHandshakeMessageType as tr, wsCarrier as tt, IActionPayload_Result_JsonObject as u, createAcceptorHandler as un, createClientHandshake as ur, IInMemoryCarrier as ut, TActionResultOutcome as v, createConnectorHandler as vn, ActionLocalHandler as vr, IActionFetchHandlerOptions as vt, EErrId_NiceAction as w, IActionTransportReadyData_Base as wn, IActionCore as wr, IServeChannelOptions as wt, isActionPayload_Any_JsonObject as x, IActionTransportDef as xn, RunningAction as xr, IExchangeAcceptorConfig as xt, isActionPayload_Result_JsonObject as y, ETransportShape as yn, createLocalHandler as yr, createActionFetchHandler as yt, EErrId_NiceTransport as z, TGetTransportFn as zn, IRuntimeFullCoordinates as zr, IHibernatableWsServerAdapterOptions as zt };
+//# sourceMappingURL=ActionPayload.types-D0DM-g65.d.mts.map

package/build/devtools/browser/index.d.cts

@@ -1,4 +1,4 @@
-import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, s as TDevtoolsPosition, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-Dd1qJAwK.cjs";
+import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, s as TDevtoolsPosition, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-dV-IVPcP.cjs";
 
 //#region src/devtools/browser/NiceActionDevtools.d.ts
 interface INiceActionDevtoolsProps {

package/build/devtools/browser/index.d.mts

@@ -1,4 +1,4 @@
-import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, s as TDevtoolsPosition, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-C5XrQI1K.mjs";
+import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, s as TDevtoolsPosition, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-D_JvgPmz.mjs";
 
 //#region src/devtools/browser/NiceActionDevtools.d.ts
 interface INiceActionDevtoolsProps {

package/build/devtools/server/index.d.cts

@@ -1,4 +1,4 @@
-import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-Dd1qJAwK.cjs";
+import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-dV-IVPcP.cjs";
 
 //#region src/devtools/server/NiceActionServerDevtools.d.ts
 type TServerDevtoolsLogFn = (message: string, data?: Record<string, unknown>) => void;

package/build/devtools/server/index.d.mts

@@ -1,4 +1,4 @@
-import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-C5XrQI1K.mjs";
+import { a as TDevtoolsActionStatus, i as IDevtoolsObservableDomain, n as IActionDevtoolsCoreOptions, o as TDevtoolsListener, r as IDevtoolsActionEntry, t as ActionDevtoolsCore } from "../../ActionDevtoolsCore-D_JvgPmz.mjs";
 
 //#region src/devtools/server/NiceActionServerDevtools.d.ts
 type TServerDevtoolsLogFn = (message: string, data?: Record<string, unknown>) => void;