@nice-code/action 0.21.0 → 0.22.0

package/README.md

@@ -45,6 +45,10 @@ The high-level entry points — `connectChannel` (dial out) and `serveChannel` (
 reach for 95% of the time. The lower-level handler/carrier/transport objects they desugar to are
 documented at the end under [Lower-level building blocks](#lower-level-building-blocks).
 
+> **Code blocks below are labelled by where they run:** `// shared.ts` (imported by both ends),
+> `// server.ts` (the acceptor), `// client.ts` (the connector). A typical app is exactly these three
+> files.
+
 ---
 
 ## Defining actions
@@ -52,6 +56,7 @@ documented at the end under [Lower-level building blocks](#lower-level-building-
 ### 1. Create a root domain (shared between both ends)
 
 ```ts
+// shared.ts
 import { createActionRootDomain, actionSchema } from "@nice-code/action";
 import * as v from "valibot";
 
@@ -159,6 +164,7 @@ A **local handler** runs actions in the current process. Build one and register
 is what answers incoming requests.
 
 ```ts
+// server.ts
 import { ActionRuntime, createLocalHandler, RuntimeCoordinate } from "@nice-code/action";
 
 export const serverCoord = RuntimeCoordinate.env("backend");
@@ -194,9 +200,10 @@ for local-first clients that resolve a few actions themselves and forward the re
 
 `serveChannel` is the one call that stands up an acceptor: it builds the crypto identity **once**, fans it
 across every carrier, registers your handlers, wires hibernation, and returns a server object whose
-`fetch` / `duplex` / `pushToClient` you forward straight to the host.
+`fetch` / `receive` / `drop` / `pushToClient` you forward straight to the host.
 
 ```ts
+// server.ts
 import {
   ActionRuntime,
   RuntimeCoordinate,
@@ -217,29 +224,35 @@ const server = serveChannel(runtime, appChannel, {
   ],
 });
 
-// Wire the host's events to the server:
+// Wire the host's events to the server — `receive`/`drop` are the universal forwarding seam:
 //   fetch(req)                     => server.fetch(req)
-//   webSocketMessage(ws, msg)      => server.duplex?.receive(ws, msg)
-//   webSocketClose/Error(ws)       => server.duplex?.drop(ws)
+//   webSocketMessage(ws, msg)      => server.receive(ws, msg)
+//   webSocketClose/Error(ws)       => server.drop(ws)
 ```
 
-`serveChannel(runtime, channel, options)` returns `{ handlers, fetch, duplex?, pushToClient }`:
+`serveChannel(runtime, channel, options)` returns `{ handlers, fetch, receive, drop, pushToClient, broadcast }`:
 
 - **`fetch`** — a web-standard handler that does the WS upgrade, the (secure or plain) HTTP action POST,
   CORS preflight, and a `404` fallback. Forward the host's `fetch` straight to it.
-- **`duplex`** — the `{ receive, drop }` lifecycle for the *sole* duplex carrier (a shortcut for the
-  common single-WebSocket case; `undefined` when there are zero or several — then feed each carrier
-  handle directly).
-- **`pushToClient(target, request, opts?)`** — push a server-initiated action to one connected client
-  (see [Bi-directional](#bi-directional-communication-acceptor--connector)).
+- **`receive(conn, frame)` / `drop(conn)`** — the universal connection lifecycle; forward your host's
+  message and close/error events here. Routes to the sole duplex carrier (the common single-WebSocket
+  case); with several duplex carriers, feed each carrier handle directly.
+- **`pushToClient(target, request, opts?)`** / **`broadcast(makeRequest, opts?)`** — push a
+  server-initiated action to one / every connected client (see
+  [Bi-directional](#bi-directional-communication-acceptor--connector)).
 - **`handlers`** — the acceptor handlers it built, one per duplex carrier (reach for these for per-handler
   `broadcast`).
 
 Key options: `clientEnv` (required), `storage` (required only when a carrier is secure — the default),
-`carriers`, `handlers`, plus `securityLevel` / `link` / `verifyKeyResolver` / `defaultTimeout`.
+`carriers`, `handlers`, `channelCases` (connection-aware cases — see below), plus `securityLevel` /
+`link` / `verifyKeyResolver` / `defaultTimeout`.
 
 > On Cloudflare, [`@nice-code/action/platform/cloudflare`](#cloudflare-durable-objects) collapses the
-> Durable Object carrier + storage boilerplate to one-liners.
+> Durable Object carrier + storage + lifecycle boilerplate into a single `serveDurableObject` call.
+>
+> Serving in another environment (Bun, Node, …)? `serveChannel`'s carriers are environment-neutral, and
+> `serveHost(runtime, channel, hostAdapter, options)` folds a reusable `{ carriers, storage, onServed }`
+> host adapter into it — the same seam `serveDurableObject` is built on.
 
 ### Connecting — `connectChannel`
 
@@ -251,6 +264,7 @@ from `onPush` — all derived from the channel, no restated lists. It's the exac
 `serveChannel`.
 
 ```ts
+// client.ts
 import {
   ActionRuntime,
   RuntimeCoordinate,
@@ -292,10 +306,11 @@ connectChannel(clientRuntime, appChannel, {
 
 ## Calling actions
 
-Once a runtime is wired, calling an action looks the same regardless of where it resolves (locally or
-over a carrier):
+Once a runtime is wired, calling an action looks the same on **any** side — client or server — and
+regardless of where it resolves (locally or over a carrier):
 
 ```ts
+// any runtime with the domain wired
 // Run and get the output directly (throws on a declared/transport error)
 const output = await userDomain.action.getUser
   .request({ userId: "u_123" })
@@ -325,7 +340,7 @@ connection — no second channel, no polling. The shape:
 ### Shared channel
 
 ```ts
-// Bidirectional: client sends `start_feed`; server pushes `position_update` back.
+// shared.ts — bidirectional: client sends `start_feed`; server pushes `position_update` back.
 export const lobbyDomain = appRoot.createChildDomain({
   domain: "lobby",
   actions: {
@@ -347,6 +362,7 @@ export const appChannel = defineSecureChannel({
 ### Connector side — handle pushes with `onPush`
 
 ```ts
+// client.ts
 connectChannel(clientRuntime, appChannel, {
   peer: serverCoord,
   storage,
@@ -366,6 +382,7 @@ connectChannel(clientRuntime, appChannel, {
 The local handler reads `action.context.originClient` to know who asked, then pushes to them:
 
 ```ts
+// server.ts
 const lobbyHandler = createLocalHandler().forDomainActionCases(lobbyDomain, {
   start_feed: async (action) => {
     let delivered = 0;
@@ -392,26 +409,28 @@ server.broadcast(
 );
 ```
 
-> **When a handler needs the originating connection itself** (to register it in a room, etc.) rather than
-> just the client coordinate, pass `channelCases` to `serveChannel` — each case receives the request *and*
-> that client's live connection. With several duplex carriers (no sole handler), reach for a specific
-> `server.handlers[i].broadcast(...)` and `acceptChannelConnections(handler, channel, { ... })` directly
-> (see [Lower-level building blocks](#lower-level-building-blocks)).
+> **When a handler needs the originating connection itself** (to register it in a room, track per-socket
+> state, etc.) rather than just the client coordinate, pass `channelCases` to `serveChannel` /
+> `serveDurableObject` — each case receives the request *and* an `IConnectionContext` (`conn.state` /
+> `conn.setState` / `conn.broadcast({ exceptSelf }) ` / `conn.pushBack` / `conn.connection`). With several
+> duplex carriers (no sole handler), reach for a specific `server.handlers[i].broadcast(...)` and
+> `acceptChannelConnections(handler, channel, { ... })` directly (see
+> [Lower-level building blocks](#lower-level-building-blocks)).
 
 ---
 
 ## Cloudflare Durable Objects
 
-`@nice-code/action/platform/cloudflare` collapses the DO boilerplate (the `WebSocketPair` upgrade, the
-hibernation attachment wiring, and the DO-storage adapter) into one-liners you hand to `serveChannel`.
-The core library stays platform-agnostic — nothing here is reachable from the main entry.
+`@nice-code/action/platform/cloudflare` collapses the *entire* DO transport stack — the hibernatable
+secure WebSocket, an HTTP fallback, the DO-storage crypto identity, and the `ping`/`pong` keepalive —
+into a single `serveDurableObject` call, leaving the DO to forward its four socket lifecycle methods. The
+core library stays platform-agnostic — nothing here is reachable from the main entry.
 
 ```ts
 import { DurableObject } from "cloudflare:workers";
-import { ActionRuntime, serveChannel, httpAcceptorCarrier } from "@nice-code/action";
+import { ActionRuntime } from "@nice-code/action";
 import {
-  durableObjectWsCarrier,
-  durableObjectStorage,
+  serveDurableObject,
   type TDurableObjectChannelServer,
 } from "@nice-code/action/platform/cloudflare";
 
@@ -422,13 +441,12 @@ export class MyDurableObject extends DurableObject {
     if (this._server != null) return this._server;
     const runtime = new ActionRuntime(serverCoord);
 
-    // One WS carrier (duplex — pushes + hibernation persistence) + a secure HTTP fallback (exchange),
-    // both sharing one crypto identity built from this DO's storage, surviving eviction.
-    this._server = serveChannel(runtime, appChannel, {
+    // Hibernatable secure WS + plain HTTP fallback + DO-storage crypto identity + keepalive, all folded in.
+    this._server = serveDurableObject(this.ctx, appChannel, {
+      runtime,
       clientEnv: RuntimeCoordinate.env("frontend"),
-      storage: durableObjectStorage(this.ctx, { keyPrefix: "ws:" }),
+      keyPrefix: "ws:",
       handlers: [userHandler],
-      carriers: [durableObjectWsCarrier(this.ctx), httpAcceptorCarrier()],
     });
     return this._server;
   }
@@ -437,40 +455,53 @@ export class MyDurableObject extends DurableObject {
     return this.getServer().fetch(request);
   }
   async webSocketMessage(ws: WebSocket, msg: string | ArrayBuffer) {
-    this.getServer().duplex?.receive(ws, msg);
+    this.getServer().receive(ws, msg);
   }
-  async webSocketClose(ws: WebSocket) { this.getServer().duplex?.drop(ws); }
-  async webSocketError(ws: WebSocket) { this.getServer().duplex?.drop(ws); }
+  async webSocketClose(ws: WebSocket) { this.getServer().drop(ws); }
+  async webSocketError(ws: WebSocket) { this.getServer().drop(ws); }
 }
 ```
 
-- **`durableObjectWsCarrier(ctx, { secure? })`** — a hibernatable-WebSocket acceptor carrier with `send`,
-  the `WebSocketPair` upgrade, and the socket-attachment access all derived from the DO's `ctx`. Pass
-  `secure: false` for a plain WS endpoint (then no `storage` is needed for it). It exposes the attachment to
-  `serveChannel`, which owns the layout: it persists the routing binding there and (when `connectionState`
-  is requested) co-stores per-connection app state in the *same* slot, so both survive eviction.
-- **`durableObjectStorage(ctx, { keyPrefix? })`** — wraps the DO's storage as a `StorageAdapter` for
-  `serveChannel`'s `storage`.
+`serveDurableObject(ctx, channel, options)` takes the same `serveChannel` surface (`clientEnv`,
+`handlers`, `channelCases`, `connectionState`, …) plus the host knobs:
+
+- **`runtime`** — this DO's runtime.
+- **`keyPrefix`** — namespace for the DO-storage crypto-identity keys.
+- **`httpFallback`** — `"plain"` (default), `"secure"` (handshake-protected exchange sharing the WS
+  identity), or `false` (WebSocket only).
+- **`secure`** — whether the WebSocket itself runs the handshake (default `true`).
+
+For finer control the lower-level pieces are still exported: `cloudflareDurableObjectHost(ctx, opts)`
+builds just the `{ carriers, storage, onServed }` host adapter (hand it to `serveHost`), and
+`durableObjectWsCarrier` / `durableObjectStorage` build the individual carrier / storage adapter.
 
 ### Per-connection state + broadcast (stateful DOs)
 
-A presence/room DO that tracks who's on each socket and fans messages out adds two `serveChannel` knobs —
-no `handlers[0]`, no hand-wired attachment store:
+A presence/room DO that tracks who's on each socket and fans messages out adds two knobs —
+`connectionState` (typed per-socket app state, co-stored with the routing binding so both survive a wake)
+and `channelCases`. Each case gets an **`IConnectionContext`** as its second argument — the originating
+connection plus everything a case reaches for, so it never threads `ws` through `server.connections` /
+`server.broadcast` by hand:
 
 ```ts
-const server = serveChannel(runtime, lobbyChannel, {
+const server = serveDurableObject(this.ctx, lobbyChannel, {
+  runtime,
   clientEnv: RuntimeCoordinate.env("web"),
-  storage: durableObjectStorage(this.ctx, { keyPrefix: "lobby-ws:" }),
-  carriers: [durableObjectWsCarrier(this.ctx), httpAcceptorCarrier({ secure: false })],
-  // Co-store each player's identity with the routing binding in the socket attachment (survives a wake).
+  keyPrefix: "lobby-ws:",
   connectionState: { schema: vs_player },
-  // Connection-aware cases: each gets the request + the originating socket.
   channelCases: {
-    join: (action, ws) => {
-      if (ws) server.connections.set(ws, action.input); // typed by the schema
-      server.broadcast(() => lobbyPush.action.player_joined.request(action.input), { except: ws });
+    join: (action, conn) => {
+      conn.setState(action.input); // typed by the schema; co-stored with the binding
+      conn.broadcast(() => lobbyPush.action.player_joined.request(action.input), { exceptSelf: true });
       return { players: this.roster() };
     },
+    move: (action, conn) => {
+      const player = conn.state;          // this socket's typed app state (or null)
+      if (!player) return;                // a move before join is dropped
+      conn.broadcast(() => lobbyPush.action.player_moved.request({ id: player.id, ...action.input }), {
+        exceptSelf: true,
+      });
+    },
   },
 });
 
@@ -478,12 +509,12 @@ const server = serveChannel(runtime, lobbyChannel, {
 for (const [, player] of server.connections.entries()) this.players.set(player.id, player);
 ```
 
-`connectionState` narrows the return so `server.connections` is non-optional, and `server.broadcast`
-fans out over the sole duplex carrier. The store's `read`/`write` are pluggable, so a DO that prefers to
-keep state in its SQLite/KV storage rather than the socket attachment can supply its own.
-
-Because the WS carrier persists each connection's binding on bind and replays it on construction, results
-and pushes still route to the right socket after the object wakes from eviction.
+The `IConnectionContext` (`conn`) gives a case: `conn.state` / `conn.setState(x)` / `conn.clearState()`
+(the typed app state), `conn.broadcast(makeRequest, { exceptSelf })`, `conn.pushBack(request)` (push down
+this same socket), and `conn.connection` (the raw socket, `null` on the HTTP-exchange path). Passing
+`connectionState` narrows the return so `server.connections` is non-optional. Because the WS carrier
+persists each connection's binding on bind and replays it on construction, results and pushes still route
+to the right socket after the object wakes from eviction.
 
 ---
 
@@ -514,7 +545,8 @@ plain HTTP fallback by giving the acceptor a `httpAcceptorCarrier({ secure: fals
 `serveChannel` accepts **any number of duplex carriers** (e.g. WebSocket + WebRTC) plus at most one
 exchange carrier. They all share one crypto identity and one runtime, and each result/push routes back
 over the carrier its client actually connected on (connection-aware return routing). With several duplex
-carriers, `server.duplex` is `undefined` — feed each carrier handle's own `receive`/`drop` directly.
+carriers, `server.receive`/`server.drop` throw (they can't pick a carrier) — feed each carrier handle's
+own `receive`/`drop` directly.
 
 ```ts
 const ws  = wsAcceptorCarrier({ send: wsSend, upgrade, attachmentStore });
@@ -541,7 +573,7 @@ predicate is re-evaluated per action dispatch, so the transport switches on the
 holds, with no reconnect.
 
 ```ts
-// Prefer the secure socket, but only once a session id exists; fall back to HTTP meanwhile.
+// client.ts — prefer the secure socket, but only once a session id exists; fall back to HTTP meanwhile.
 connectChannel(runtime, appChannel, {
   peer: serverCoord,
   storage,

package/build/{ActionDevtoolsCore-baIHExfj.d.mts → ActionDevtoolsCore-CQ0vrvPD.d.cts}

@@ -1,4 +1,4 @@
-import { Pr as IRuntimeCoordinate, _ as TActionProgress } from "./ActionPayload.types-DXGiw1SF.mjs";
+import { _ as TActionProgress, zr as IRuntimeCoordinate } from "./ActionPayload.types-L9k0LyBd.cjs";
 //#region ../nice-devtools-shared/src/components/PanelChrome.d.ts
 /** Where a devtools panel is docked. */
 type TDevtoolsPosition = "dock-bottom" | "dock-top" | "dock-left" | "dock-right";
@@ -76,4 +76,4 @@ declare class ActionDevtoolsCore {
 }
 //#endregion
 export { TDevtoolsActionStatus as a, IDevtoolsObservableDomain as i, IActionDevtoolsCoreOptions as n, TDevtoolsListener as o, IDevtoolsActionEntry as r, TDevtoolsPosition as s, ActionDevtoolsCore as t };
-//# sourceMappingURL=ActionDevtoolsCore-baIHExfj.d.mts.map
+//# sourceMappingURL=ActionDevtoolsCore-CQ0vrvPD.d.cts.map

package/build/{ActionDevtoolsCore-dApyYvTS.d.cts → ActionDevtoolsCore-CiLBYC3K.d.mts}

@@ -1,4 +1,4 @@
-import { Pr as IRuntimeCoordinate, _ as TActionProgress } from "./ActionPayload.types-CQM1HRw_.cjs";
+import { _ as TActionProgress, zr as IRuntimeCoordinate } from "./ActionPayload.types-Dx1JPyfs.mjs";
 //#region ../nice-devtools-shared/src/components/PanelChrome.d.ts
 /** Where a devtools panel is docked. */
 type TDevtoolsPosition = "dock-bottom" | "dock-top" | "dock-left" | "dock-right";
@@ -76,4 +76,4 @@ declare class ActionDevtoolsCore {
 }
 //#endregion
 export { TDevtoolsActionStatus as a, IDevtoolsObservableDomain as i, IActionDevtoolsCoreOptions as n, TDevtoolsListener as o, IDevtoolsActionEntry as r, TDevtoolsPosition as s, ActionDevtoolsCore as t };
-//# sourceMappingURL=ActionDevtoolsCore-dApyYvTS.d.cts.map
+//# sourceMappingURL=ActionDevtoolsCore-CiLBYC3K.d.mts.map

package/build/{ActionPayload.types-CQM1HRw_.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];
@@ -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
@@ -1958,14 +1971,16 @@ interface IConnectChannelOptions<TO_CONNECTOR extends readonly ActionDomain<any>
  * 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, 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;
+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
@@ -1975,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")`),
@@ -2274,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")`),
@@ -2320,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`,
@@ -2342,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
@@ -2380,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
@@ -2407,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 {
@@ -3264,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 { 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-CQM1HRw_.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