@nice-code/action 0.20.0 → 0.22.0

package/build/{ActionPayload.types-CnfWlkA1.d.cts → ActionPayload.types-Dx1JPyfs.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[];
@@ -1529,12 +1529,21 @@ type IAcceptorHandlerOptions<TConn> = IAcceptorHandlerBaseOptions<TConn> & ({
   formatMessage?: never;
 });
 /**
- * A connection-aware execution case (see {@link AcceptorHandler.forConnectionDomainCases}). It
- * receives the primed request plus the originating client's live connection (already resolved from the
- * request's `originClient`, `undefined` if the socket is gone), and may return the action's raw output,
- * a result payload, or nothing (auto-wrapped as an empty success) — exactly like a local handler case.
+ * A connection-aware execution case (see {@link AcceptorHandler.forConnectionDomainCases}). It receives
+ * the primed request plus a per-invocation `context` — whatever the wiring's context mapper produces from
+ * the originating connection. The low-level handler passes the raw connection (`TConn | undefined`); the
+ * higher-level `serveChannel` enriches it into an `IConnectionContext` (state + broadcast + pushBack). A
+ * case may return the action's raw output, a result payload, or nothing (auto-wrapped as an empty
+ * success) — exactly like a local handler case.
  */
-type TAcceptorConnectionCaseFn<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, TConn> = (action: TDistributeActionPayload_Request<DOM, ID>, connection: TConn | undefined) => ReturnType<THandleActionExecutionFn<DOM, ID>> | void;
+type TAcceptorCaseFn<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, TCtx> = (action: TDistributeActionPayload_Request<DOM, ID>, context: TCtx) => ReturnType<THandleActionExecutionFn<DOM, ID>> | void;
+/**
+ * The connection-aware case the bare {@link AcceptorHandler} serves: its `context` is the originating
+ * client's live connection (resolved from the request's `originClient`, `undefined` if the socket is
+ * gone). It's {@link TAcceptorCaseFn} fixed to `TConn | undefined` — the un-enriched shape used by
+ * {@link AcceptorHandler.forConnectionDomainCases} and `acceptChannelConnections`.
+ */
+type TAcceptorConnectionCaseFn<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, TConn> = TAcceptorCaseFn<DOM, ID, TConn | undefined>;
 /**
  * Server-side handler for backends that accept many client connections over a single open channel
  * (WebSockets, Durable Objects, …). It is transport-agnostic: you feed it inbound frames with
@@ -1648,11 +1657,15 @@ declare class AcceptorHandler<TConn = unknown> extends PeerLinkHandler {
   forConnectionDomainCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: { [ID in keyof FOR_DOM["actionSchema"] & string]?: TAcceptorConnectionCaseFn<FOR_DOM, ID, TConn> }): ActionLocalHandler;
   /**
    * Like {@link forConnectionDomainCases} but spanning several domains with one merged case map — used
-   * by channel-derived wiring (`acceptChannelConnections`) where the channel's `toAcceptor` domains are
-   * served together. Each domain takes only the cases whose ids it owns, so a single map can cover
-   * several domains and unrelated ids are ignored.
+   * by channel-derived wiring (`acceptChannelConnections` / `serveChannel`) where the channel's
+   * `toAcceptor` domains are served together. Each domain takes only the cases whose ids it owns, so a
+   * single map can cover several domains and unrelated ids are ignored.
+   *
+   * `mapContext` turns the resolved connection into whatever the case's second argument should be: the
+   * raw connection for the low-level helper, or an enriched `IConnectionContext` for `serveChannel`. It's
+   * called once per inbound action, after the originating connection is resolved.
    */
-  forConnectionDomainCasesMulti(domains: readonly ActionDomain<any>[], cases: Record<string, TAcceptorConnectionCaseFn<any, any, TConn> | undefined>): ActionLocalHandler;
+  forConnectionDomainCasesMulti<TCtx>(domains: readonly ActionDomain<any>[], cases: Record<string, TAcceptorCaseFn<any, any, TCtx> | undefined>, mapContext: (connection: TConn | undefined, request: ActionPayload_Request<any, any>) => TCtx): ActionLocalHandler;
   /**
    * Fan a server-initiated request out to every currently-bound connection. A fresh request is built
    * per connection (each push mutates its own action context) and dispatched fire-and-forget. Pass
@@ -1679,6 +1692,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,40 +1898,89 @@ 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;
-type TDomainAcceptorCases<D, TConn> = D extends ActionDomain<infer DEF> ? { [ID in keyof DEF["actionSchema"] & string]?: TAcceptorConnectionCaseFn<DEF, ID, TConn> } : never;
+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, TCtx> = D extends ActionDomain<infer DEF> ? { [ID in keyof DEF["actionSchema"] & string]?: TAcceptorCaseFn<DEF, ID, TCtx> } : never;
 /**
  * The connection-aware case map for a channel's acceptor side: the merged set of every
- * connector→acceptor (`toAcceptor`) action handler, each receiving the primed request plus the
- * originating connection. Derived from the channel's `toAcceptorDomains`, so the keys and input/output
- * types follow the channel.
+ * connector→acceptor (`toAcceptor`) action handler, each receiving the primed request plus a per-action
+ * `context`. `TCtx` is whatever the wiring supplies as that second argument — the raw connection
+ * (`TConn | undefined`) for the low-level `acceptChannelConnections`, or an enriched `IConnectionContext`
+ * for `serveChannel`'s `channelCases`. Derived from the channel's `toAcceptorDomains`, so the keys and
+ * input/output types follow the channel.
  */
-type TChannelAcceptorCases<TO_ACCEPTOR extends readonly ActionDomain<any>[], TConn> = TUnionToIntersection<TDomainAcceptorCases<TO_ACCEPTOR[number], TConn>>;
+type TChannelAcceptorCases<TO_ACCEPTOR extends readonly ActionDomain<any>[], TCtx> = TUnionToIntersection<TDomainAcceptorCases<TO_ACCEPTOR[number], TCtx>>;
 /**
  * Register an acceptor handler's execution for a channel straight from its definition: the channel's
  * `toAcceptor` domains are served together with one merged, connection-aware case map (each case gets
@@ -1837,8 +1990,11 @@ type TChannelAcceptorCases<TO_ACCEPTOR extends readonly ActionDomain<any>[], TCo
  * ```ts
  * runtime.addHandlers([acceptChannelConnections(serverHandler, channel, { … }), serverHandler]);
  * ```
+ *
+ * The case's second argument is the raw connection (`TConn | undefined`). For the richer state +
+ * broadcast + pushBack context, serve the channel through `serveChannel`'s `channelCases` instead.
  */
-declare function acceptChannelConnections<TO_ACCEPTOR extends readonly ActionDomain<any>[], TConn>(serverHandler: AcceptorHandler<TConn>, channel: IActionChannel<TO_ACCEPTOR, any>, cases: TChannelAcceptorCases<TO_ACCEPTOR, TConn>): ActionLocalHandler;
+declare function acceptChannelConnections<TO_ACCEPTOR extends readonly ActionDomain<any>[], TConn>(serverHandler: AcceptorHandler<TConn>, channel: IActionChannel<TO_ACCEPTOR, any>, cases: TChannelAcceptorCases<TO_ACCEPTOR, TConn | undefined>): ActionLocalHandler;
 interface IAcceptChannelOptions<TConn> {
   /**
    * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
@@ -2001,97 +2157,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}
@@ -2227,6 +2292,43 @@ interface IServeConnectionStateOptions<TApp> {
    */
   schema?: StandardSchemaV1<unknown, TApp>;
 }
+/**
+ * The per-action handle a `serveChannel` `channelCases` case receives as its second argument — the
+ * originating connection enriched with everything a case typically reaches for, so it never threads
+ * `ws` through `this.connections` / `this.server` by hand:
+ *
+ * - {@link state} / {@link setState} / {@link clearState} — the connection's typed app state (when
+ *   `connectionState` is configured), co-stored with the routing binding so it survives hibernation.
+ * - {@link broadcast} — fan a server push to every other connection (skip self with `exceptSelf`).
+ * - {@link pushBack} — push a server-initiated action down *this* same connection.
+ *
+ * Over the HTTP-exchange path there is no live socket: {@link connection} is `null`, {@link state} reads
+ * `null`, {@link setState}/{@link clearState} are no-ops, and {@link pushBack} throws (an exchange reply
+ * rides its own request — it can't carry an unsolicited push).
+ */
+interface IConnectionContext<TConn, TApp = unknown> {
+  /** The originating live connection, or `null` on the HTTP-exchange path (escape hatch). */
+  connection: TConn | null;
+  /** The originating client's coordinate (`= action.context.originClient`). */
+  origin: RuntimeCoordinate;
+  /** This connection's app state, or `null` if unset / no live socket. */
+  state: TApp | null;
+  /** Set this connection's app state (no-op without a live socket). Preserves the routing binding. */
+  setState: (value: TApp) => void;
+  /** Clear this connection's app state but keep the routing binding (no-op without a live socket). */
+  clearState: () => void;
+  /** Fan a server-initiated action out to every connection; `exceptSelf` skips this one. */
+  broadcast: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(makeRequest: () => ActionPayload_Request<DOM, ID>, options?: {
+    exceptSelf?: boolean;
+    where?: (connection: TConn) => boolean;
+    timeout?: number;
+    onError?: (error: unknown, connection: TConn) => void;
+  }) => void;
+  /** Push a server-initiated action down this same connection. Throws if there is no live socket. */
+  pushBack: <DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(request: ActionPayload_Request<DOM, ID>, options?: {
+    timeout?: number;
+  }) => RunningAction<DOM, ID>;
+}
 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")`),
@@ -2273,10 +2375,11 @@ interface IServeChannelOptions<TO_ACCEPTOR extends readonly ActionDomain<any>[],
   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.
+   * primed request *and* an {@link IConnectionContext} (the connection plus its typed `state` and
+   * `broadcast`/`pushBack`). The connection-aware dual of `handlers`, registered on the runtime for you.
+   * Requires exactly one duplex carrier.
    */
-  channelCases?: TChannelAcceptorCases<TO_ACCEPTOR, TConn>;
+  channelCases?: TChannelAcceptorCases<TO_ACCEPTOR, IConnectionContext<TConn, TApp>>;
 }
 /**
  * One server serving a secure channel over several carriers — the accept-in dual of `connectChannel`,
@@ -2295,11 +2398,17 @@ interface IChannelServer<TConn, TApp = unknown> {
    */
   fetch: (request: Request) => Promise<Response>;
   /**
-   * Convenience lifecycle for the *sole* duplex carrier — `receive` inbound frames, `drop` on close. Set
-   * only when exactly one duplex carrier was provided; with several, feed each carrier handle directly
-   * (every duplex carrier is its own lifecycle handle). `undefined` when there are zero or multiple.
+   * Feed one inbound frame from a live connection into the server — forward your host's "message" event
+   * here (a Durable Object's `webSocketMessage`, a Bun `websocket.message`, a Node `ws.on("message")`).
+   * Routes to the sole duplex carrier; throws with a clear message when there are zero or several duplex
+   * carriers (for the multi-carrier case feed each `handlers[i]` / carrier handle directly).
    */
-  duplex?: IDuplexConnectionRouter<TConn>;
+  receive: (connection: TConn, frame: string | Uint8Array | ArrayBuffer) => void;
+  /**
+   * Forget a connection on close/error — forward your host's "close"/"error" event here. Routes to the
+   * sole duplex carrier; a no-op when there are none (an HTTP-only server has no sockets to drop).
+   */
+  drop: (connection: TConn) => void;
   /**
    * Push a server-initiated action to a connected client (the runtime is bound in, so unlike
    * {@link AcceptorHandler.pushToClient} you pass only the target + request). It routes through the duplex
@@ -2333,21 +2442,24 @@ interface IChannelServer<TConn, TApp = unknown> {
  * `(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 exposes an attachment store, and returns a single
- * {@link IChannelServer} whose `fetch` / `duplex` / `pushToClient` / `broadcast` you forward straight to
- * the host:
+ * {@link IChannelServer} whose `fetch` / `receive` / `drop` / `pushToClient` / `broadcast` you forward
+ * straight to the host:
  * ```ts
  * const server = serveChannel(runtime, channel, {
  *   clientEnv, storage,
  *   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
+ *   channelCases: { join: (action, conn) => { conn.setState(action.input); … } }, // connection-aware cases
  * });
  * // fetch(req) => server.fetch(req)
- * // webSocketMessage(conn, m) => server.duplex?.receive(conn, m)
- * // webSocketClose/Error(conn) => server.duplex?.drop(conn)
+ * // webSocketMessage(conn, m) => server.receive(conn, m)
+ * // webSocketClose/Error(conn) => server.drop(conn)
  * // server.connections.get(conn) / server.broadcast(() => push.request(…), { except: conn })
  * ```
  *
+ * On Cloudflare, `serveDurableObject` folds the whole DO transport stack (carriers + storage + keepalive)
+ * into this — reach for it instead of assembling the carriers by hand.
+ *
  * `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. Passing `connectionState` narrows the return so
@@ -2360,6 +2472,44 @@ declare function serveChannel<TO_ACCEPTOR extends readonly ActionDomain<any>[],
 };
 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/Channel/serveHost.d.ts
+/**
+ * An environment-neutral description of *where* a channel is served — the accept-in dual of a connector's
+ * transport stack, factored out so a platform adapter (a Cloudflare Durable Object, a Bun/Node WebSocket
+ * server, …) supplies only what differs per environment while the channel + case wiring stays identical.
+ * A host bundles:
+ *
+ * - the {@link carriers} the channel is served over (e.g. a WebSocket + an HTTP fallback),
+ * - the {@link storage} backing the server's crypto identity, and
+ * - an {@link onServed} hook run once the server exists (e.g. registering a keepalive auto-response).
+ *
+ * Build one with a platform helper (`cloudflareDurableObjectHost`) and hand it to {@link serveHost}.
+ */
+interface IChannelHostAdapter<TConn> {
+  /** The carriers this channel is served over — the accept-in dual of `connectChannel`'s `transports`. */
+  carriers: readonly TAcceptorCarrier<TConn>[];
+  /** Backing store for the server's crypto identity + TOFU pins. Required when any carrier is secure. */
+  storage?: StorageAdapter;
+  /** Run once after the server is built — e.g. register a transport keepalive. */
+  onServed?: (server: IChannelServer<TConn, unknown>) => void;
+}
+/** {@link serveChannel}'s options minus what the host adapter supplies (`carriers`, `storage`). */
+type TServeHostOptions<TO_ACCEPTOR extends readonly ActionDomain<any>[], TConn, TApp = unknown> = Omit<IServeChannelOptions<TO_ACCEPTOR, TConn, TApp>, "carriers" | "storage">;
+/**
+ * Serve a channel over a {@link IChannelHostAdapter} — the environment-neutral core every platform helper
+ * (e.g. `serveDurableObject`) composes. It folds the host's carriers + storage into `serveChannel`, then
+ * runs the host's `onServed` hook. Everything else (`clientEnv`, `channelCases`, `connectionState`,
+ * `handlers`, …) is the same `serveChannel` surface, so moving a server between environments is swapping
+ * the host adapter and nothing else. Passing `connectionState` narrows the return so `server.connections`
+ * is non-optional, exactly as with `serveChannel`.
+ */
+declare function serveHost<TO_ACCEPTOR extends readonly ActionDomain<any>[], TO_CONNECTOR extends readonly ActionDomain<any>[], TConn, TApp>(runtime: ActionRuntime, channel: ISecureChannel<TO_ACCEPTOR, TO_CONNECTOR>, host: IChannelHostAdapter<TConn>, options: TServeHostOptions<TO_ACCEPTOR, TConn, TApp> & {
+  connectionState: IServeConnectionStateOptions<TApp>;
+}): IChannelServer<TConn, TApp> & {
+  connections: ConnectionStateStore<TConn, TApp>;
+};
+declare function serveHost<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>, host: IChannelHostAdapter<TConn>, options: TServeHostOptions<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. */
 interface IExchangeAcceptorSecurity {
@@ -2943,47 +3093,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
@@ -3033,45 +3142,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",
@@ -3297,5 +3367,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 $, 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-CnfWlkA1.d.cts.map
+export { wsAcceptorCarrier as $, TTransportStatusInfo_GetTransport_Output as $n, TPossibleDomainId as $r, IDuplexCarrier as $t, encodeExchange as A, ITransportDispatchAction as An, ERunningActionUpdateType as Ar, TAcceptorCarrier as At, IActionFrameCrypto as B, IUpdateActionRunConfig_Output as Bn, IRuntimeCoordinateSpecifics as Br, IActionChannel as Bt, decodeActionFrame as C, IActionTransportDef as Cn, RunningAction as Cr, IConnectionContext as Ct, TExchangeRequest as D, IActionTransportReadyData_Methods as Dn, IActionCore_JsonObject as Dr, IAcceptorAttachmentStore as Dt, TExchangeReply as E, IActionTransportReadyData_Base as En, IActionCore as Er, serveChannel as Et, EErrId_NiceTransport as F, ITransportStatusInfo_Base as Fn, TRunningActionUpdate as Fr, ConnectionStateStore as Ft, IHttpCarrierRequest as G, TOnResolveIncomingRequestJson as Gn, IActionDomain as Gr, acceptChannel as Gt, createActionFrameCrypto as H, TOnResolveAnyIncomingActionData as Hn, RuntimeCoordinate as Hr, IConnectTransport as Ht, err_nice_transport as I, ITransportStatusInfo_Failed as In, TRunningActionUpdateFinished as Ir, IConnectionAttachment as It, IHttpAcceptorCarrierOptions as J, TSendActionDataMethod as Jn, TActionDomainChildDef as Jr, defineChannel as Jt, TCarrierFetch as K, TOnResolveIncomingResponse as Kn, IActionDomainChildOptions as Kr, acceptChannelConnections as Kt, ExchangeTransport as L, ITransportStatusInfo_Initializing as Ln, TRunningActionUpdateListener as Lr, IConnectionStateStoreOptions as Lt, LinkTransport as M, ITransportRouteActionParams as Mn, IRunningActionUpdate_Progress as Mr, IDuplexConnectionRouter as Mt, IActionTransportReadyData_Link as N, ITransportRouteClientParams as Nn, IRunningActionUpdate_Started as Nr, IHibernatableWsServerAdapterOptions as Nt, decodeExchangeReply as O, IActionTransportResolvers as On, ERunningActionFinishedType as Or, IDuplexAcceptorCarrier as Ot, TLinkFormatMessage as P, ITransportRouteInfo as Pn, IRunningActionUpdate_Success as Pr, createHibernatableWsServerAdapter as Pt, IWsAcceptorCarrierOptions as Q, TTransportStatusInfo as Qn, TInferOutputFromSchema as Qr, createBinaryWireSessionFactory as Qt, IExchangeTransportOptions as R, ITransportStatusInfo_Ready as Rn, ActionPayload_Result as Rr, createConnectionStateStore as Rt, IActionFrameDecoder as S, ETransportStatus as Sn, MaybePromise as Sr, IChannelServer as St, err_nice_action as T, IActionTransportReady as Tn, ActionPayload_Request as Tr, IServeConnectionStateOptions as Tt, createBinaryWireAdapter as U, TOnResolveAnyIncomingActionData_Json as Un, TRuntimeCoordinateEnvId as Ur, TChannelAcceptorCases as Ut, IActionFrameCryptoConfig as V, TGetTransportFn as Vn, IRuntimeFullCoordinates as Vr, IConnectChannelOptions as Vt, IHttpCarrierOptions as W, TOnResolveIncomingRequest as Wn, TRuntimeCoordinateStringId as Wr, TChannelPushHandlers as Wt, IWsCarrierOptions as X, TTransportCache as Xn, TDomainActionId as Xr, defineSecureChannel as Xt, httpAcceptorCarrier as Y, TSendReturnDataMethod as Yn, TActionDomainSchema as Yr, ISecureChannel as Yt, wsCarrier as Z, TTransportInitializationFinishedInfo as Zn, TInferInputFromSchema as Zr, IBinaryWireSessionOptions as Zt, TActionProgress as _, ActionRootDomain as _n, encodeHandshakeMessage as _r, IExchangeAcceptorConfig as _t, IActionPayload_Data_Base as a, TActionSchemaOptions as ai, AcceptorHandler as an, IClientHandshakeConfig as ar, rtcDataChannelByteChannel as at, isActionPayload_Request_JsonObject as b, createConnectorHandler as bn, ActionLocalHandler as br, TServeHostOptions as bt, IActionPayload_Request_JsonObject as c, TAcceptorCaseFn as cn, IHandshakeEncryptionKeyMaterial as cr, IInMemoryChannelPair as ct, IActionProgress_Custom as d, TActionConnectionEncoding as dn, THandshakeMessage as dr, err_nice_external_client as dt, TPossibleDomainIdList as ei, IDuplexCarrierSource as en, TUpdateActionRunConfig as er, EErrId_NiceTransport_WebSocket as et, IActionProgress_None as f, createAcceptorHandler as fn, createClientHandshake as fr, ISecureAcceptorHandlerOptions as ft, TActionPayload_Any_JsonObject as g, ActionDomain as gn, decodeHandshakeMessage as gr, ExchangeAcceptor as gt, TActionPayload_Any_Instance as h, ActionCore as hn, createStorageTofuVerifyKeyResolver as hr, createActionFetchHandler as ht, IActionPayload_Base_JsonObject as i, actionSchema as ii, TFrame$1 as in, ESecurityLevel as ir, IRtcDataChannelLike as it, ILinkTransportOptions as j, ITransportMethod_SendActionData_Input as jn, IRunningActionUpdate_Abort as jr, isExchangeAcceptorCarrier as jt, decodeExchangeRequest as k, ISecureClientConfig as kn, ERunningActionState as kr, IExchangeAcceptorCarrier as kt, IActionPayload_Result as l, TAcceptorConnectionCaseFn as ln, IHandshakeResult as lr, IInMemoryServerEndpoint as lt, IActionRouteItemHandler as m, createActionRootDomain as mn, createServerHandshake as mr, IActionFetchHandlerOptions as mt, EActionProgressType as n, EActionResponseMode as ni, IExchangeCarrierSource as nn, Transport as nr, IRtcCarrierOptions as nt, IActionPayload_Progress as o, TActionSerializationDefinition as oi, IAcceptorConnectionBinding as on, IClientVerifyKeyResolveInput as or, IInMemoryCarrier as ot, IActionProgress_Percentage as p, IActionWireFormat as pn, createInMemoryTofuVerifyKeyResolver as pr, createSecureAcceptorHandler as pt, httpCarrier as q, TOnResolveIncomingResponseJson as qn, IActionRootDomain as qr, connectChannel as qt, IActionPayload_Base as r, TInferActionError as ri, TCarrier as rn, EHandshakeMessageType as rr, rtcCarrier as rt, IActionPayload_Progress_JsonObject as s, TTransportedValue as si, IAcceptorHandlerOptions as sn, IClientVerifyKeyResolver as sr, inMemoryCarrier as st, EActionPayloadType as t, ActionSchema as ti, IExchangeCarrier as tn, ITransportConnectionContext as tr, err_nice_transport_ws as tt, IActionPayload_Result_JsonObject as u, TActionChannelFormatMessage as un, IServerHandshakeConfig as ur, createInMemoryChannelPair as ut, TActionResultOutcome as v, ActionRuntime as vn, runtimeLinkId as vr, IExchangeAcceptorSecurity as vt, EErrId_NiceAction as w, IActionTransportInitialized as wn, ActionPayload_Progress as wr, IServeChannelOptions as wt, isActionPayload_Any_JsonObject as x, ETransportShape as xn, createLocalHandler as xr, serveHost as xt, isActionPayload_Result_JsonObject as y, ConnectorHandler as yn, PeerLinkHandler as yr, IChannelHostAdapter as yt, IActionTransportReadyData_Exchange as z, ITransportStatusInfo_Unsupported as zn, IRuntimeCoordinate as zr, IAcceptChannelOptions as zt };
+//# sourceMappingURL=ActionPayload.types-Dx1JPyfs.d.mts.map