@nice-code/action 0.19.0 → 0.21.0

package/build/{ActionPayload.types-CdHOGGZK.d.cts → ActionPayload.types-DXGiw1SF.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];
@@ -1283,16 +1283,16 @@ declare class ActionRuntime {
    */
   addHandlers(handlers: TActionRuntimeHandler[]): this;
   /**
+   * @internal Low-level primitive — the public way to open a connection is `connectChannel`, which
+   * derives routing from a channel and binds the crypto identity for you. This stays as the raw building
+   * block it sits on (it restates domain lists by hand) and is not part of the supported surface.
+   *
    * Declare an external "backend client" in one call: build an
    * {@link ConnectorHandler} for `externalCoordinate` carrying the given
    * `transports`, route the listed `domains`/`actions` to it, register it (plus any
    * `localHandlers` — e.g. server→client push handlers that share the same channel)
    * on this runtime, and `apply()`. Returns the external handler so the caller can
    * later `clearTransportCache()` it.
-   *
-   * Sugar over `new ConnectorHandler(...).forDomain(...)` + `addHandlers([...])`,
-   * so a single runtime can host one handler per backend target with its transports
-   * declared once and reused across every action routed to that backend.
    */
   connectTo(externalCoordinate: RuntimeCoordinate, options: {
     transports: Transport[];
@@ -1679,6 +1679,97 @@ declare class AcceptorHandler<TConn = unknown> extends PeerLinkHandler {
 }
 declare const createAcceptorHandler: <TConn = unknown>(options: IAcceptorHandlerOptions<TConn>) => AcceptorHandler<TConn>;
 //#endregion
+//#region src/ActionRuntime/Transport/Carrier/Carrier.types.d.ts
+/**
+ * Carrier shapes — the only transport-specific surface a new protocol must implement. The secure
+ * session (handshake + frame crypto + codec) and the action routing on top of it are carrier-agnostic;
+ * a carrier just moves frames. Two shapes capture every carrier:
+ *
+ * - {@link IDuplexCarrier} — a persistent, push-capable byte stream (WebSocket, WebRTC `RTCDataChannel`,
+ *   Bluetooth GATT, an in-memory pipe). Either side can send at any time, so it supports server→client
+ *   pushes (the return path + broadcast).
+ * - {@link IExchangeCarrier} — a request → single-correlated-reply carrier with no unsolicited push
+ *   (HTTP, and anything request/response-shaped). The reply rides the response to its own request.
+ *
+ * Frames are `string` (text — handshake control messages and JSON action frames) or binary
+ * (`Uint8Array`/`ArrayBuffer` — the optimized binary wire / encrypted frames).
+ */
+type TFrame$1 = string | Uint8Array | ArrayBuffer;
+/**
+ * A bidirectional, push-capable byte stream. Reduces every duplex carrier to "open, send bytes, receive
+ * bytes, close" — a WebSocket, a WebRTC data channel, a Bluetooth characteristic, or an in-memory pipe
+ * all satisfy this, so the identical secure session runs over each.
+ */
+interface IDuplexCarrier {
+  /** Resolves once the carrier is open and ready to send; rejects if it closes/errors before opening. */
+  readonly ready: Promise<void>;
+  /** Whether the carrier is currently open (a synchronous guard before `send`). */
+  isOpen(): boolean;
+  /** Write one frame to the peer. */
+  send(frame: TFrame$1): void;
+  /**
+   * Register the carrier's handlers. Called exactly once by the session after `ready`. `onMessage`
+   * receives every inbound frame; `onClose` fires when the carrier goes away.
+   */
+  attach(handlers: {
+    onMessage: (frame: TFrame$1) => void;
+    onClose: () => void;
+    onError?: (error: unknown) => void;
+  }): void;
+  /** Close the carrier deliberately (a teardown). */
+  close(): void;
+  /** Optional human-readable endpoint for the devtools route chip. */
+  readonly label?: string;
+}
+/**
+ * A request → single-correlated-reply carrier with no unsolicited push (HTTP). One `exchange` sends a
+ * frame and resolves with exactly the one reply frame for it; the carrier itself correlates them (the
+ * HTTP transaction), so no correlation id is needed on the wire.
+ */
+interface IExchangeCarrier {
+  /** Send one frame, await the single correlated reply frame. */
+  exchange(frame: TFrame$1, opts?: {
+    signal?: AbortSignal;
+  }): Promise<TFrame$1>;
+  /** Optional human-readable endpoint for the devtools route chip. */
+  readonly label?: string;
+}
+type TCarrier = IDuplexCarrier | IExchangeCarrier;
+/**
+ * A reusable opener for a {@link IDuplexCarrier} plus the per-action metadata a duplex transport needs.
+ * Built by the small carrier factories (`wsCarrier`, `rtcCarrier`, `inMemoryCarrier`) and handed to
+ * {@link secureTransport} / `LinkTransport` — so adding a new carrier is "write one of these", nothing
+ * else.
+ */
+interface IDuplexCarrierSource {
+  /** Open (or reuse) the carrier for an action. */
+  open: (input: ITransportRouteActionParams) => IDuplexCarrier;
+  /** Keys identifying a reusable carrier, so one carrier is shared across actions to the same peer. */
+  getCacheKey?: (input: ITransportRouteActionParams) => string[];
+  /** Devtools route info for an action routed over this carrier. */
+  getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
+  /** Short carrier-kind label for the devtools chip (e.g. `"ws"`, `"webrtc"`, `"memory"`). */
+  readonly carrierLabel: string;
+}
+/**
+ * The exchange-shape counterpart to {@link IDuplexCarrierSource}: a reusable opener for an
+ * {@link IExchangeCarrier} plus the per-action metadata an exchange transport needs. Built by
+ * `httpCarrier` and handed to {@link secureTransport} — adding a new request/reply protocol is "write
+ * one of these". The `shape` tag lets {@link secureTransport} pick the duplex vs exchange transport.
+ */
+interface IExchangeCarrierSource {
+  /** Discriminant so a generic factory can tell an exchange source from a duplex one. */
+  readonly shape: "exchange";
+  /** Open (or reuse) the carrier for an action. */
+  open: (input: ITransportRouteActionParams) => IExchangeCarrier;
+  /** Keys identifying a reusable carrier, so one carrier is shared across actions to the same peer. */
+  getCacheKey?: (input: ITransportRouteActionParams) => string[];
+  /** Devtools route info for an action routed over this carrier. */
+  getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
+  /** Short carrier-kind label for the devtools chip (e.g. `"http"`). */
+  readonly carrierLabel: string;
+}
+//#endregion
 //#region src/ActionRuntime/Transport/codec/createBinaryWireSessionFactory.d.ts
 type TFormatMessage = IActionWireFormat;
 interface IBinaryWireSessionOptions {
@@ -1794,32 +1885,79 @@ type TDomainPushHandlers<D> = D extends ActionDomain<infer DEF> ? Partial<TWrapp
  * the keys and input types follow the channel definition.
  */
 type TChannelPushHandlers<TO_CONNECTOR extends readonly ActionDomain<any>[]> = TUnionToIntersection<TDomainPushHandlers<TO_CONNECTOR[number]>>;
-interface IConnectChannelOptions<TO_ACCEPTOR extends readonly ActionDomain<any>[], TO_CONNECTOR extends readonly ActionDomain<any>[]> {
-  /** The shared channel — its `toAcceptorDomains`/`toConnectorDomains` drive all routing. */
-  channel: IActionChannel<TO_ACCEPTOR, TO_CONNECTOR>;
+/**
+ * One transport to the peer, declared by *carrier* — the dial-out dual of `serveChannel`'s acceptor
+ * carriers. {@link connectChannel} binds the shared facts (channel codec/version, runtime, crypto
+ * identity) into each one, so a descriptor only carries what differs between transports: the carrier and
+ * whether it runs the secure handshake.
+ *
+ * A duplex carrier (`wsCarrier(url)`, `rtcCarrier(dc)`) builds a push-capable link; an exchange carrier
+ * (`httpCarrier(...)`) builds a request/reply transport. List them in preference order — the connection
+ * prefers the first that's ready and falls through on failure (e.g. secure WS preferred, HTTP fallback).
+ */
+interface IConnectTransport {
+  /** How to reach the peer — a duplex carrier (push-capable) or an exchange carrier (request/reply). */
+  carrier: IDuplexCarrierSource | IExchangeCarrierSource;
   /**
-   * Transports to the acceptor, in preference order (e.g. `[wsTransport, httpFallback]`). They all carry
-   * the same `toAcceptor` domains; the manager prefers the first that's ready and falls through on
-   * failure — so connector→acceptor works over whatever transport is available, WS or HTTP.
+   * Run the authenticated/encrypted handshake over this carrier. Defaults to `true`. A secure transport
+   * draws its identity from the connection's shared `link`/`storage`; set `false` for a plain transport
+   * (e.g. a bare HTTP fallback beside a secure WS), which then needs no `storage`.
    */
-  transports: Transport[];
+  secure?: boolean;
+  /** Security level for this secure transport; defaults to the connection-level `securityLevel`. */
+  securityLevel?: ESecurityLevel;
+  /**
+   * Optional availability gate — when it returns `false` this transport is skipped and the connection
+   * falls through to the next in preference order, re-evaluated per dispatch. Omit = always available.
+   */
+  available?: (input: ITransportRouteActionParams) => boolean;
+  /** Override the devtools chip label (defaults to the carrier's own label). */
+  label?: string;
+}
+interface IConnectChannelOptions<TO_CONNECTOR extends readonly ActionDomain<any>[]> {
+  /** The peer's runtime coordinate — the acceptor this connection dials. */
+  peer: RuntimeCoordinate;
+  /**
+   * The transports to the peer, by carrier, in preference order (e.g. secure WS preferred, HTTP fallback).
+   * They all carry the channel's `toAcceptor` domains; the connection prefers the first that's ready and
+   * falls through on failure. {@link connectChannel} binds the channel + runtime + crypto identity into
+   * each — the dial-out dual of `serveChannel`'s `carriers`.
+   */
+  transports: readonly IConnectTransport[];
+  /**
+   * One backing store for this connection's crypto identity, fanned across every *secure* transport so
+   * they present the same verify/exchange keys. Required when any transport is secure (the default); a
+   * fully-plain connection (every transport `secure: false`) may omit it. Pass `link` instead to share an
+   * existing identity.
+   */
+  storage?: StorageAdapter;
+  /** The connection's crypto identity. Defaults to a fresh {@link ClientCryptoKeyLink} over `storage`. */
+  link?: ClientCryptoKeyLink;
+  /** Default security level for secure transports; defaults to `authenticated`. */
+  securityLevel?: ESecurityLevel;
   /** Handlers for the channel's acceptor→connector pushes. Optional — omit for a send-only connection. */
   onPush?: TChannelPushHandlers<TO_CONNECTOR>;
   /** Default per-action timeout for this connection. */
   defaultTimeout?: number;
 }
 /**
- * Wire a connection to the acceptor straight from a channel: route the channel's `toAcceptor` domains to
- * the acceptor over `transports`, and register local handlers for its `toConnector` pushes from
- * `onPush`. The channel is the single source of truth for *what* is routed in each direction — the
- * caller only supplies the transport(s) and the push handlers, never restated domain lists. Pass several
- * transports to make the connector→acceptor path transport-agnostic (e.g. secure WS preferred, HTTP
- * fallback).
- *
- * Sugar over {@link ActionRuntime.connectTo}. Returns the acceptor handler so the caller can later
- * `clearTransportCache()` it.
+ * Open a connection to a peer from a single call — the dial-out dual of `serveChannel`. The channel is
+ * the single source of truth for *what* is routed (`toAcceptor` domains forwarded to the peer,
+ * `toConnector` pushes handled locally from `onPush`); the call binds the shared facts — the channel's
+ * codec/dictionary version, the runtime, and one crypto identity (a {@link ClientCryptoKeyLink} over
+ * `storage`) — into every transport in `transports`, so none of them restate the channel or runtime.
+ * List several transports to make the path transport-agnostic (secure WS preferred, HTTP fallback):
+ * ```ts
+ * const handler = connectChannel(runtime, lobbyChannel, {
+ *   peer: runtime_coordinate_lobby_do,
+ *   storage,
+ *   transports: [{ carrier: wsCarrier(url) }, { carrier: httpCarrier(...), secure: false }],
+ *   onPush: { player_joined: (p) => { … } },
+ * });
+ * ```
+ * Returns the {@link ConnectorHandler} so the caller can later `clearTransportCache()` it.
  */
-declare function connectChannel<TO_ACCEPTOR extends readonly ActionDomain<any>[], TO_CONNECTOR extends readonly ActionDomain<any>[]>(runtime: ActionRuntime, acceptorCoordinate: RuntimeCoordinate, options: IConnectChannelOptions<TO_ACCEPTOR, TO_CONNECTOR>): ConnectorHandler;
+declare function connectChannel<TO_ACCEPTOR extends readonly ActionDomain<any>[], TO_CONNECTOR extends readonly ActionDomain<any>[]>(runtime: ActionRuntime, channel: ISecureChannel<TO_ACCEPTOR, TO_CONNECTOR>, options: IConnectChannelOptions<TO_CONNECTOR>): ConnectorHandler;
 type TDomainAcceptorCases<D, TConn> = D extends ActionDomain<infer DEF> ? { [ID in keyof DEF["actionSchema"] & string]?: TAcceptorConnectionCaseFn<DEF, ID, TConn> } : never;
 /**
  * The connection-aware case map for a channel's acceptor side: the merged set of every
@@ -1878,6 +2016,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`). */
@@ -1919,97 +2139,6 @@ interface IDuplexConnectionRouter<TConn> {
  */
 declare function createHibernatableWsServerAdapter<TConn>(options: IHibernatableWsServerAdapterOptions<TConn>): IDuplexConnectionRouter<TConn>;
 //#endregion
-//#region src/ActionRuntime/Transport/Carrier/Carrier.types.d.ts
-/**
- * Carrier shapes — the only transport-specific surface a new protocol must implement. The secure
- * session (handshake + frame crypto + codec) and the action routing on top of it are carrier-agnostic;
- * a carrier just moves frames. Two shapes capture every carrier:
- *
- * - {@link IDuplexCarrier} — a persistent, push-capable byte stream (WebSocket, WebRTC `RTCDataChannel`,
- *   Bluetooth GATT, an in-memory pipe). Either side can send at any time, so it supports server→client
- *   pushes (the return path + broadcast).
- * - {@link IExchangeCarrier} — a request → single-correlated-reply carrier with no unsolicited push
- *   (HTTP, and anything request/response-shaped). The reply rides the response to its own request.
- *
- * Frames are `string` (text — handshake control messages and JSON action frames) or binary
- * (`Uint8Array`/`ArrayBuffer` — the optimized binary wire / encrypted frames).
- */
-type TFrame$1 = string | Uint8Array | ArrayBuffer;
-/**
- * A bidirectional, push-capable byte stream. Reduces every duplex carrier to "open, send bytes, receive
- * bytes, close" — a WebSocket, a WebRTC data channel, a Bluetooth characteristic, or an in-memory pipe
- * all satisfy this, so the identical secure session runs over each.
- */
-interface IDuplexCarrier {
-  /** Resolves once the carrier is open and ready to send; rejects if it closes/errors before opening. */
-  readonly ready: Promise<void>;
-  /** Whether the carrier is currently open (a synchronous guard before `send`). */
-  isOpen(): boolean;
-  /** Write one frame to the peer. */
-  send(frame: TFrame$1): void;
-  /**
-   * Register the carrier's handlers. Called exactly once by the session after `ready`. `onMessage`
-   * receives every inbound frame; `onClose` fires when the carrier goes away.
-   */
-  attach(handlers: {
-    onMessage: (frame: TFrame$1) => void;
-    onClose: () => void;
-    onError?: (error: unknown) => void;
-  }): void;
-  /** Close the carrier deliberately (a teardown). */
-  close(): void;
-  /** Optional human-readable endpoint for the devtools route chip. */
-  readonly label?: string;
-}
-/**
- * A request → single-correlated-reply carrier with no unsolicited push (HTTP). One `exchange` sends a
- * frame and resolves with exactly the one reply frame for it; the carrier itself correlates them (the
- * HTTP transaction), so no correlation id is needed on the wire.
- */
-interface IExchangeCarrier {
-  /** Send one frame, await the single correlated reply frame. */
-  exchange(frame: TFrame$1, opts?: {
-    signal?: AbortSignal;
-  }): Promise<TFrame$1>;
-  /** Optional human-readable endpoint for the devtools route chip. */
-  readonly label?: string;
-}
-type TCarrier = IDuplexCarrier | IExchangeCarrier;
-/**
- * A reusable opener for a {@link IDuplexCarrier} plus the per-action metadata a duplex transport needs.
- * Built by the small carrier factories (`wsCarrier`, `rtcCarrier`, `inMemoryCarrier`) and handed to
- * {@link secureTransport} / `LinkTransport` — so adding a new carrier is "write one of these", nothing
- * else.
- */
-interface IDuplexCarrierSource {
-  /** Open (or reuse) the carrier for an action. */
-  open: (input: ITransportRouteActionParams) => IDuplexCarrier;
-  /** Keys identifying a reusable carrier, so one carrier is shared across actions to the same peer. */
-  getCacheKey?: (input: ITransportRouteActionParams) => string[];
-  /** Devtools route info for an action routed over this carrier. */
-  getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
-  /** Short carrier-kind label for the devtools chip (e.g. `"ws"`, `"webrtc"`, `"memory"`). */
-  readonly carrierLabel: string;
-}
-/**
- * The exchange-shape counterpart to {@link IDuplexCarrierSource}: a reusable opener for an
- * {@link IExchangeCarrier} plus the per-action metadata an exchange transport needs. Built by
- * `httpCarrier` and handed to {@link secureTransport} — adding a new request/reply protocol is "write
- * one of these". The `shape` tag lets {@link secureTransport} pick the duplex vs exchange transport.
- */
-interface IExchangeCarrierSource {
-  /** Discriminant so a generic factory can tell an exchange source from a duplex one. */
-  readonly shape: "exchange";
-  /** Open (or reuse) the carrier for an action. */
-  open: (input: ITransportRouteActionParams) => IExchangeCarrier;
-  /** Keys identifying a reusable carrier, so one carrier is shared across actions to the same peer. */
-  getCacheKey?: (input: ITransportRouteActionParams) => string[];
-  /** Devtools route info for an action routed over this carrier. */
-  getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
-  /** Short carrier-kind label for the devtools chip (e.g. `"http"`). */
-  readonly carrierLabel: string;
-}
-//#endregion
 //#region src/ActionRuntime/Transport/Carrier/AcceptorCarrier.types.d.ts
 /**
  * Acceptor-side carrier descriptors — the accept-in dual of the connector's {@link IDuplexCarrierSource}
@@ -2029,17 +2158,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
@@ -2086,8 +2219,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;
 }
@@ -2129,7 +2266,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.
@@ -2166,12 +2311,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
@@ -2197,6 +2355,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
@@ -2204,24 +2379,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. */
@@ -2368,88 +2552,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;
@@ -2575,8 +2677,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;
 }
@@ -2888,47 +2990,6 @@ declare class LinkTransport extends Transport<ETransportShape.duplex> {
   getRouteInfo(input: ITransportRouteActionParams): ITransportRouteInfo;
 }
 //#endregion
-//#region src/ActionRuntime/Transport/plainTransport.d.ts
-interface IPlainTransportOptions {
-  /**
-   * How to reach the peer with no security layer. A duplex carrier (`wsCarrier(url)`,
-   * `rtcCarrier(dc)`, `inMemoryCarrier().carrier`) builds a push-capable {@link LinkTransport}; an
-   * exchange carrier (`httpCarrier(...)`) builds a request/reply {@link ExchangeTransport}.
-   */
-  carrier: IDuplexCarrierSource | IExchangeCarrierSource;
-  /**
-   * Codec for a *duplex* carrier (a duplex link frames the action wire itself). Required for duplex;
-   * ignored for an exchange carrier, which JSON-encodes the action wire in its envelope.
-   */
-  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;
-}
-/**
- * The plain (no-handshake, no-crypto) sibling of {@link secureTransport}: swap the carrier to change
- * protocol, with no security layer. Over an {@link IExchangeCarrierSource} it builds an
- * {@link ExchangeTransport} that POSTs the bare action wire and completes inline (HTTP is just
- * `carrier: httpCarrier(...)`); over an {@link IDuplexCarrierSource} it builds a push-capable
- * {@link LinkTransport} with the given codec. HTTP is therefore no longer a bespoke transport class —
- * it is "just another carrier", exactly like a WebSocket under {@link secureTransport}.
- */
-declare function plainTransport(options: IPlainTransportOptions & {
-  carrier: IExchangeCarrierSource;
-}): ExchangeTransport;
-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
@@ -2978,45 +3039,6 @@ declare function encodeExchange(envelope: TExchangeRequest | TExchangeReply): st
 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. */
-  channel: ISecureChannel;
-  /** This client's runtime — its coordinate is the authenticated identity sent in the handshake. */
-  runtime: ActionRuntime;
-  /** Backing store for this client's crypto identity (a stable verify key across reloads). */
-  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(...)`)
-   * runs the request/reply session over the same handshake + crypto.
-   */
-  carrier: IDuplexCarrierSource | IExchangeCarrierSource;
-}
-/**
- * The one secure-transport factory — swap the carrier to change protocol. Folds in the boilerplate (the
- * {@link ClientCryptoKeyLink} from `storageAdapter`, the `security` block from the runtime coordinate +
- * channel version) and drives it over whatever carrier you pass: a {@link IDuplexCarrierSource} builds a
- * push-capable {@link LinkTransport} (WS is just `carrier: wsCarrier(url)`), an
- * {@link IExchangeCarrierSource} builds a request/reply {@link ExchangeTransport} (HTTP, with the same
- * authentication/encryption). Replaces the old `createSecureWebSocketTransport` / `createSecureLinkTransport`.
- */
-declare function secureTransport(options: ISecureTransportOptions & {
-  carrier: IDuplexCarrierSource;
-}): LinkTransport;
-declare function secureTransport(options: ISecureTransportOptions & {
-  carrier: IExchangeCarrierSource;
-}): ExchangeTransport;
-//#endregion
 //#region src/errors/err_nice_action.d.ts
 declare enum EErrId_NiceAction {
   not_implemented = "not_implemented",
@@ -3242,5 +3264,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 { httpAcceptorCarrier as $, Transport as $n, EActionResponseMode as $r, ISecureChannel as $t, decodeExchangeReply as A, ITransportRouteClientParams as An, IRunningActionUpdate_Started as Ar, IAcceptorHibernation as At, err_nice_transport as B, TOnResolveAnyIncomingActionData_Json as Bn, TRuntimeCoordinateEnvId as Br, TFrame$1 as Bt, decodeActionFrame as C, IActionTransportReadyData_Base as Cn, IActionCore as Cr, createActionFetchHandler as Ct, secureTransport as D, ITransportDispatchAction as Dn, ERunningActionUpdateType as Dr, IChannelServer as Dt, ISecureTransportOptions as E, ISecureClientConfig as En, ERunningActionState as Er, IExchangeAcceptorSecurity as Et, ILinkTransportOptions as F, ITransportStatusInfo_Ready as Fn, ActionPayload_Result as Fr, IDuplexCarrier as Ft, IActionFrameCryptoConfig as G, TSendActionDataMethod as Gn, TActionDomainChildDef as Gr, IActionChannel as Gt, IExchangeTransportOptions as H, TOnResolveIncomingRequestJson as Hn, IActionDomain as Hr, IHibernatableWsServerAdapterOptions as Ht, LinkTransport as I, ITransportStatusInfo_Unsupported as In, IRuntimeCoordinate as Ir, IDuplexCarrierSource as It, IHttpCarrierOptions as J, TTransportInitializationFinishedInfo as Jn, TInferInputFromSchema as Jr, TChannelPushHandlers as Jt, createActionFrameCrypto as K, TSendReturnDataMethod as Kn, TActionDomainSchema as Kr, IConnectChannelOptions as Kt, IActionTransportReadyData_Link as L, IUpdateActionRunConfig_Output as Ln, IRuntimeCoordinateSpecifics as Lr, IExchangeCarrier as Lt, encodeExchange as M, ITransportStatusInfo_Base as Mn, TRunningActionUpdate as Mr, IExchangeAcceptorCarrier as Mt, IPlainTransportOptions as N, ITransportStatusInfo_Failed as Nn, TRunningActionUpdateFinished as Nr, TAcceptorCarrier as Nt, TExchangeReply as O, ITransportMethod_SendActionData_Input as On, IRunningActionUpdate_Abort as Or, IServeChannelOptions as Ot, plainTransport as P, ITransportStatusInfo_Initializing as Pn, TRunningActionUpdateListener as Pr, isExchangeAcceptorCarrier as Pt, IHttpAcceptorCarrierOptions as Q, ITransportConnectionContext as Qn, ActionSchema as Qr, defineChannel as Qt, TLinkFormatMessage as R, TGetTransportFn as Rn, IRuntimeFullCoordinates as Rr, IExchangeCarrierSource as Rt, IActionFrameDecoder as S, IActionTransportReady as Sn, ActionPayload_Request as Sr, IActionFetchHandlerOptions as St, err_nice_action as T, IActionTransportResolvers as Tn, ERunningActionFinishedType as Tr, IExchangeAcceptorConfig as Tt, IActionTransportReadyData_Exchange as U, TOnResolveIncomingResponse as Un, IActionDomainChildOptions as Ur, createHibernatableWsServerAdapter as Ut, ExchangeTransport as V, TOnResolveIncomingRequest as Vn, TRuntimeCoordinateStringId as Vr, IDuplexConnectionRouter as Vt, IActionFrameCrypto as W, TOnResolveIncomingResponseJson as Wn, IActionRootDomain as Wr, IAcceptChannelOptions as Wt, TCarrierFetch as X, TTransportStatusInfo_GetTransport_Output as Xn, TPossibleDomainId as Xr, acceptChannelConnections as Xt, IHttpCarrierRequest as Y, TTransportStatusInfo as Yn, TInferOutputFromSchema as Yr, acceptChannel as Yt, httpCarrier as Z, TUpdateActionRunConfig as Zn, TPossibleDomainIdList as Zr, connectChannel as Zt, TActionProgress as _, createConnectorHandler as _n, ActionLocalHandler as _r, IConnectionAttachment as _t, IActionPayload_Data_Base as a, IAcceptorHandlerOptions as an, IHandshakeEncryptionKeyMaterial as ar, err_nice_transport_ws as at, isActionPayload_Request_JsonObject as b, IActionTransportDef as bn, RunningAction as br, ISecureAcceptorHandlerOptions as bt, IActionPayload_Request_JsonObject as c, TActionConnectionEncoding as cn, THandshakeMessage as cr, IRtcDataChannelLike as ct, IActionProgress_Custom as d, createActionRootDomain as dn, createServerHandshake as dr, inMemoryCarrier as dt, TInferActionError as ei, defineSecureChannel as en, EHandshakeMessageType as er, IWsCarrierOptions as et, IActionProgress_None as f, ActionCore as fn, createStorageTofuVerifyKeyResolver as fr, IInMemoryChannelPair as ft, TActionPayload_Any_JsonObject as g, ConnectorHandler as gn, PeerLinkHandler as gr, ConnectionStateStore as gt, TActionPayload_Any_Instance as h, ActionRuntime as hn, runtimeLinkId as hr, err_nice_external_client as ht, IActionPayload_Base_JsonObject as i, TTransportedValue as ii, IAcceptorConnectionBinding as in, IClientVerifyKeyResolver as ir, EErrId_NiceTransport_WebSocket as it, decodeExchangeRequest as j, ITransportRouteInfo as jn, IRunningActionUpdate_Success as jr, IDuplexAcceptorCarrier as jt, TExchangeRequest as k, ITransportRouteActionParams as kn, IRunningActionUpdate_Progress as kr, serveChannel as kt, IActionPayload_Result as l, createAcceptorHandler as ln, createClientHandshake as lr, rtcDataChannelByteChannel as lt, IActionRouteItemHandler as m, ActionRootDomain as mn, encodeHandshakeMessage as mr, createInMemoryChannelPair as mt, EActionProgressType as n, TActionSchemaOptions as ni, createBinaryWireSessionFactory as nn, IClientHandshakeConfig as nr, IWsAcceptorCarrierOptions as nt, IActionPayload_Progress as o, TAcceptorConnectionCaseFn as on, IHandshakeResult as or, IRtcCarrierOptions as ot, IActionProgress_Percentage as p, ActionDomain as pn, decodeHandshakeMessage as pr, IInMemoryServerEndpoint as pt, createBinaryWireAdapter as q, TTransportCache as qn, TDomainActionId as qr, TChannelAcceptorCases as qt, IActionPayload_Base as r, TActionSerializationDefinition as ri, AcceptorHandler as rn, IClientVerifyKeyResolveInput as rr, wsAcceptorCarrier as rt, IActionPayload_Progress_JsonObject as s, TActionChannelFormatMessage as sn, IServerHandshakeConfig as sr, rtcCarrier as st, EActionPayloadType as t, actionSchema as ti, IBinaryWireSessionOptions as tn, ESecurityLevel as tr, wsCarrier as tt, IActionPayload_Result_JsonObject as u, IActionWireFormat as un, createInMemoryTofuVerifyKeyResolver as ur, IInMemoryCarrier as ut, TActionResultOutcome as v, ETransportShape as vn, createLocalHandler as vr, IConnectionStateStoreOptions as vt, EErrId_NiceAction as w, IActionTransportReadyData_Methods as wn, IActionCore_JsonObject as wr, ExchangeAcceptor as wt, isActionPayload_Any_JsonObject as x, IActionTransportInitialized as xn, ActionPayload_Progress as xr, createSecureAcceptorHandler as xt, isActionPayload_Result_JsonObject as y, ETransportStatus as yn, MaybePromise as yr, createConnectionStateStore as yt, EErrId_NiceTransport as z, TOnResolveAnyIncomingActionData as zn, RuntimeCoordinate as zr, TCarrier as zt };
-//# sourceMappingURL=ActionPayload.types-CdHOGGZK.d.cts.map
+export { wsAcceptorCarrier as $, ESecurityLevel as $n, actionSchema as $r, TCarrier as $t, encodeExchange as A, ITransportStatusInfo_Base as An, TRunningActionUpdate as Ar, createHibernatableWsServerAdapter as At, IActionFrameCrypto as B, TOnResolveIncomingRequestJson as Bn, IActionDomain as Br, TChannelPushHandlers as Bt, decodeActionFrame as C, IActionTransportResolvers as Cn, ERunningActionFinishedType as Cr, IAcceptorAttachmentStore as Ct, TExchangeRequest as D, ITransportRouteActionParams as Dn, IRunningActionUpdate_Progress as Dr, isExchangeAcceptorCarrier as Dt, TExchangeReply as E, ITransportMethod_SendActionData_Input as En, IRunningActionUpdate_Abort as Er, TAcceptorCarrier as Et, EErrId_NiceTransport as F, IUpdateActionRunConfig_Output as Fn, IRuntimeCoordinateSpecifics as Fr, IAcceptChannelOptions as Ft, IHttpCarrierRequest as G, TTransportCache as Gn, TDomainActionId as Gr, ISecureChannel as Gt, createActionFrameCrypto as H, TOnResolveIncomingResponseJson as Hn, IActionRootDomain as Hr, acceptChannelConnections as Ht, err_nice_transport as I, TGetTransportFn as In, IRuntimeFullCoordinates as Ir, IActionChannel as It, IHttpAcceptorCarrierOptions as J, TTransportStatusInfo_GetTransport_Output as Jn, TPossibleDomainId as Jr, createBinaryWireSessionFactory as Jt, TCarrierFetch as K, TTransportInitializationFinishedInfo as Kn, TInferInputFromSchema as Kr, defineSecureChannel as Kt, ExchangeTransport as L, TOnResolveAnyIncomingActionData as Ln, RuntimeCoordinate as Lr, IConnectChannelOptions as Lt, LinkTransport as M, ITransportStatusInfo_Initializing as Mn, TRunningActionUpdateListener as Mr, IConnectionAttachment as Mt, IActionTransportReadyData_Link as N, ITransportStatusInfo_Ready as Nn, ActionPayload_Result as Nr, IConnectionStateStoreOptions as Nt, decodeExchangeReply as O, ITransportRouteClientParams as On, IRunningActionUpdate_Started as Or, IDuplexConnectionRouter as Ot, TLinkFormatMessage as P, ITransportStatusInfo_Unsupported as Pn, IRuntimeCoordinate as Pr, createConnectionStateStore as Pt, IWsAcceptorCarrierOptions as Q, EHandshakeMessageType as Qn, TInferActionError as Qr, IExchangeCarrierSource as Qt, IExchangeTransportOptions as R, TOnResolveAnyIncomingActionData_Json as Rn, TRuntimeCoordinateEnvId as Rr, IConnectTransport as Rt, IActionFrameDecoder as S, IActionTransportReadyData_Methods as Sn, IActionCore_JsonObject as Sr, serveChannel as St, err_nice_action as T, ITransportDispatchAction as Tn, ERunningActionUpdateType as Tr, IExchangeAcceptorCarrier as Tt, createBinaryWireAdapter as U, TSendActionDataMethod as Un, TActionDomainChildDef as Ur, connectChannel as Ut, IActionFrameCryptoConfig as V, TOnResolveIncomingResponse as Vn, IActionDomainChildOptions as Vr, acceptChannel as Vt, IHttpCarrierOptions as W, TSendReturnDataMethod as Wn, TActionDomainSchema as Wr, defineChannel as Wt, IWsCarrierOptions as X, ITransportConnectionContext as Xn, ActionSchema as Xr, IDuplexCarrierSource as Xt, httpAcceptorCarrier as Y, TUpdateActionRunConfig as Yn, TPossibleDomainIdList as Yr, IDuplexCarrier as Yt, wsCarrier as Z, Transport as Zn, EActionResponseMode as Zr, IExchangeCarrier as Zt, TActionProgress as _, ETransportStatus as _n, MaybePromise as _r, IExchangeAcceptorConfig as _t, IActionPayload_Data_Base as a, TActionChannelFormatMessage as an, IServerHandshakeConfig as ar, rtcDataChannelByteChannel as at, isActionPayload_Request_JsonObject as b, IActionTransportReady as bn, ActionPayload_Request as br, IServeChannelOptions as bt, IActionPayload_Request_JsonObject as c, IActionWireFormat as cn, createInMemoryTofuVerifyKeyResolver as cr, IInMemoryChannelPair as ct, IActionProgress_Custom as d, ActionDomain as dn, decodeHandshakeMessage as dr, err_nice_external_client as dt, TActionSchemaOptions as ei, TFrame$1 as en, IClientHandshakeConfig as er, EErrId_NiceTransport_WebSocket as et, IActionProgress_None as f, ActionRootDomain as fn, encodeHandshakeMessage as fr, ISecureAcceptorHandlerOptions as ft, TActionPayload_Any_JsonObject as g, ETransportShape as gn, createLocalHandler as gr, ExchangeAcceptor as gt, TActionPayload_Any_Instance as h, createConnectorHandler as hn, ActionLocalHandler as hr, createActionFetchHandler as ht, IActionPayload_Base_JsonObject as i, TAcceptorConnectionCaseFn as in, IHandshakeResult as ir, IRtcDataChannelLike as it, ILinkTransportOptions as j, ITransportStatusInfo_Failed as jn, TRunningActionUpdateFinished as jr, ConnectionStateStore as jt, decodeExchangeRequest as k, ITransportRouteInfo as kn, IRunningActionUpdate_Success as kr, IHibernatableWsServerAdapterOptions as kt, IActionPayload_Result as l, createActionRootDomain as ln, createServerHandshake as lr, IInMemoryServerEndpoint as lt, IActionRouteItemHandler as m, ConnectorHandler as mn, PeerLinkHandler as mr, IActionFetchHandlerOptions as mt, EActionProgressType as n, TTransportedValue as ni, IAcceptorConnectionBinding as nn, IClientVerifyKeyResolver as nr, IRtcCarrierOptions as nt, IActionPayload_Progress as o, TActionConnectionEncoding as on, THandshakeMessage as or, IInMemoryCarrier as ot, IActionProgress_Percentage as p, ActionRuntime as pn, runtimeLinkId as pr, createSecureAcceptorHandler as pt, httpCarrier as q, TTransportStatusInfo as qn, TInferOutputFromSchema as qr, IBinaryWireSessionOptions as qt, IActionPayload_Base as r, IAcceptorHandlerOptions as rn, IHandshakeEncryptionKeyMaterial as rr, rtcCarrier as rt, IActionPayload_Progress_JsonObject as s, createAcceptorHandler as sn, createClientHandshake as sr, inMemoryCarrier as st, EActionPayloadType as t, TActionSerializationDefinition as ti, AcceptorHandler as tn, IClientVerifyKeyResolveInput as tr, err_nice_transport_ws as tt, IActionPayload_Result_JsonObject as u, ActionCore as un, createStorageTofuVerifyKeyResolver as ur, createInMemoryChannelPair as ut, TActionResultOutcome as v, IActionTransportDef as vn, RunningAction as vr, IExchangeAcceptorSecurity as vt, EErrId_NiceAction as w, ISecureClientConfig as wn, ERunningActionState as wr, IDuplexAcceptorCarrier as wt, isActionPayload_Any_JsonObject as x, IActionTransportReadyData_Base as xn, IActionCore as xr, IServeConnectionStateOptions as xt, isActionPayload_Result_JsonObject as y, IActionTransportInitialized as yn, ActionPayload_Progress as yr, IChannelServer as yt, IActionTransportReadyData_Exchange as z, TOnResolveIncomingRequest as zn, TRuntimeCoordinateStringId as zr, TChannelAcceptorCases as zt };
+//# sourceMappingURL=ActionPayload.types-DXGiw1SF.d.mts.map