@nice-code/action 0.24.0 → 0.25.0

package/README.md

@@ -234,9 +234,17 @@ const server = serveChannel(runtime, appChannel, {
 - **`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`, `channelCases` (connection-aware cases — see below), plus `securityLevel` /
-`link` / `verifyKeyResolver` / `defaultTimeout`.
+Key options: `clientEnv` (optional — see below), `storage` (required only when a carrier is secure — the
+default), `carriers`, `handlers`, `channelCases` (connection-aware cases — see below), plus
+`securityLevel` / `link` / `verifyKeyResolver` / `defaultTimeout`.
+
+> **One server, several client envs (multi-role).** `clientEnv` is **optional**. A result or push to a
+> *connected* client always routes back over the carrier it actually connected on (the acceptor knows each
+> client's exact coordinate from its handshake), so a single `serveChannel` accepts clients of *different*
+> envs — e.g. a `wallet` role and a `partner` role on one bridge — over one acceptor. Omit `clientEnv`
+> entirely for a multi-role server; only set it if you want a scoring fallback for returning to a client
+> that is *no longer connected* (the offline case). This replaces the old workaround of standing up a
+> second `serveChannel` per role.
 
 > On Cloudflare, [`@nice-code/action/platform/cloudflare`](#cloudflare-durable-objects) collapses the
 > Durable Object carrier + storage + lifecycle boilerplate into a single `serveDurableObject` call.
@@ -453,7 +461,7 @@ export class MyDurableObject extends DurableObject {
 }
 ```
 
-`serveDurableObject(ctx, channel, options)` takes the same `serveChannel` surface (`clientEnv`,
+`serveDurableObject(ctx, channel, options)` takes the same `serveChannel` surface (`clientEnv` — optional,
 `handlers`, `channelCases`, `connectionState`, …) plus the host knobs:
 
 - **`runtime`** — this DO's runtime.
@@ -466,6 +474,45 @@ For finer control the lower-level pieces are still exported: `cloudflareDurableO
 builds just the `{ carriers, storage, onServed }` host adapter (hand it to `serveHost`), and
 `durableObjectWsCarrier` / `durableObjectStorage` build the individual carrier / storage adapter.
 
+### Fanning HTTP out to a per-id Durable Object — `forwardExchangeToDurableObject`
+
+When each DO instance is one *thing* (a bridge, a room, a game) and the Worker has to pick the right one
+per request, route by the **URL** — a secure exchange body is opaque to the Worker (handshake / encrypted
+frames), so it can't choose by inspecting the body. `forwardExchangeToDurableObject` picks the stub, hands
+the request to its `fetch` (where `serveDurableObject` serves the exchange), and answers the CORS
+`OPTIONS` preflight *at the edge* so a per-id DO is never woken (or billed) just to reply to a preflight:
+
+```ts
+import { forwardExchangeToDurableObject } from "@nice-code/action/platform/cloudflare";
+
+export default {
+  fetch(request: Request, env: Env) {
+    return forwardExchangeToDurableObject(request, (req, url) => {
+      const bridgeId = url.pathname.split("/")[2];        // e.g. /bridge/:id/action
+      return env.BRIDGE.get(env.BRIDGE.idFromName(bridgeId));
+    });
+  },
+};
+```
+
+Inside the DO, serve the exchange (and the WS upgrade) exactly as above — make the HTTP fallback secure so
+the whole path is handshake-protected:
+
+```ts
+this._server = serveDurableObject(this.ctx, bridgeChannel, { runtime, httpFallback: "secure" });
+// fetch(request) => this._server.fetch(request)
+```
+
+The matching connector points its `httpCarrier` at `/bridge/:id/action`. `pickStub` may be async (e.g. to
+resolve an id first) and receives the parsed `URL` alongside the request.
+
+> Need to handle the exchange yourself instead of handing the endpoint to `serveChannel`? The secure
+> exchange acceptor and its plain `{k:"act",w}` envelope codec are exported from the **main** entry:
+> `ExchangeAcceptor` (drive the handshake + token sessions + decrypt over your own `fetch`), and
+> `encodeExchange` / `decodeExchangeRequest` / `decodeExchangeReply` (read/write the plain envelope when
+> you must inspect or rewrite the wire before running it). Secure bodies are only decodable through an
+> `ExchangeAcceptor` session — route-before-decode by URL, as above.
+
 ### Per-connection state + broadcast (stateful DOs)
 
 A presence/room DO that tracks who's on each socket and fans messages out adds two knobs —
@@ -696,9 +743,10 @@ routing that isn't a single channel.
   `connectChannel`'s `transports` (the `secure` flag picks the policy) and in `serveChannel`'s `carriers`;
   the transport wrapping happens internally, so there's no separate transport-builder to call.
 
-- **`acceptChannel(runtime, channel, { clientEnv, storage, send, ... })`** — build the secure
+- **`acceptChannel(runtime, channel, { storage, send, clientEnv?, ... })`** — build the secure
   `AcceptorHandler` for a channel by hand (the accept-in counterpart to a single transport), when you're
-  not using `serveChannel`. Pair it with **`acceptChannelConnections(handler, channel, cases)`** to
+  not using `serveChannel`. `clientEnv` is optional here too (one acceptor serves several client envs — a
+  live connection always wins the return path). Pair it with **`acceptChannelConnections(handler, channel, cases)`** to
   register connection-aware execution — each case receives the request *and* the originating connection:
 
   ```ts

package/build/{AcceptorHandler-11-QMdx2.d.mts → AcceptorHandler-BizUtq4u.d.mts}

@@ -820,9 +820,10 @@ interface ISecureAcceptorHandlerOptions<TConn> {
   channel: IActionChannel;
   /**
    * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
-   * used to route results/pushes back over this handler.
+   * used as the offline-return scoring fallback (a live connection always wins regardless). Optional —
+   * omit it for a multi-role server accepting several client envs over one acceptor.
    */
-  clientEnv: RuntimeCoordinate;
+  clientEnv?: RuntimeCoordinate;
   /** This server's runtime — its coordinate is the server identity presented in the handshake. */
   runtime: ActionRuntime;
   /**
@@ -1832,9 +1833,12 @@ interface IConnectionContext<TConn, TApp = unknown> {
 interface IServeChannelOptions<TO_ACCEPTOR extends readonly ActionDomain<any>[], TConn, TApp = unknown> {
   /**
    * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
-   * used to score return-path dispatch back to the right connection.
+   * used only as the offline-return scoring fallback — a result/push to a live client always routes over
+   * the carrier it connected on regardless of this. Optional: omit it for a multi-role server that accepts
+   * clients of several envs over one acceptor (it then scores 0 against every client, so the live
+   * connection always decides).
    */
-  clientEnv: RuntimeCoordinate;
+  clientEnv?: RuntimeCoordinate;
   /**
    * One backing store for the server's crypto identity *and* its trust-on-first-use verify-key pins
    * (their keys don't collide). It is built once and shared across every carrier, so the WebSocket and the
@@ -2265,6 +2269,101 @@ declare const err_nice_transport: import("@nice-code/error").NiceErrorDomain<{
   };
 }>;
 //#endregion
+//#region src/ActionRuntime/Transport/SecureSession/exchangeAcceptor.d.ts
+/** Acceptor secure config for the exchange (HTTP) endpoint — same identity an `AcceptorHandler` uses. */
+interface IExchangeAcceptorSecurity {
+  /** This acceptor's crypto identity (verify + exchange key pairs, optionally persisted). */
+  link: ClientCryptoKeyLink;
+  /** This acceptor's coordinate — its identity to clients during the handshake. */
+  localCoordinate: IRuntimeCoordinate;
+  /** Wire dictionary version; the handshake rejects a client on a mismatch. */
+  dictionaryVersion: string;
+  /** Accepted level(s) — a single level is strict, an array is a negotiable allowed set. */
+  securityLevel: ESecurityLevel | readonly ESecurityLevel[];
+  /** Trust decision for a client's verify key (defaults to in-memory TOFU inside the handshake). */
+  verifyKeyResolver?: IClientVerifyKeyResolver;
+}
+interface IExchangeAcceptorConfig {
+  security: IExchangeAcceptorSecurity;
+  /** The runtime that executes an inbound action wire and produces its result. */
+  runtime: ActionRuntime;
+}
+/**
+ * Acceptor (accept-in) side of the secure exchange protocol — the HTTP counterpart to
+ * {@link AcceptorSecureSession}. Each POST body is one {@link decodeExchangeRequest} envelope; the
+ * acceptor drives the server handshake over the two `hs` POSTs (correlated by `hsid`, since stateless
+ * requests can't rely on channel ordering), mints a session **token** on accept, and on every later `act`
+ * POST resolves the session by token, decrypts the body (at `encrypted`), routes it through the runtime,
+ * and returns the (encrypted) result inline as the reply.
+ *
+ * Sessions and in-flight handshakes are held in memory — fine for a single-instance server. (Surviving a
+ * Durable-Object eviction would persist each token's `keyMaterial` and re-derive the key on a miss, the
+ * same primitive `AcceptorSecureSession.rehydrate` uses; left as a follow-up.)
+ */
+declare class ExchangeAcceptor {
+  private readonly _security;
+  private readonly _runtime;
+  private readonly _allowedLevels;
+  private readonly _noneAllowed;
+  private readonly _pendingHandshakes;
+  private readonly _sessions;
+  constructor(config: IExchangeAcceptorConfig);
+  /** Process one POST body (an exchange envelope), returning the reply body to send back. */
+  handlePost(body: string): Promise<string>;
+  private _handleHandshake;
+  private _handleAction;
+  private _err;
+}
+//#endregion
+//#region src/ActionRuntime/Transport/SecureSession/exchangeProtocol.d.ts
+/**
+ * The application-level envelope for secure action traffic over an {@link IExchangeCarrier} (HTTP). An
+ * exchange carrier only moves one request frame → one reply frame with no unsolicited push, so the
+ * handshake and the per-action token + crypto all ride in this envelope (a JSON string body) rather than
+ * on a persistent channel. The three security levels share it:
+ *
+ * - `none` — no handshake, no token: an `act` envelope carries the plaintext wire both ways.
+ * - `authenticated` — a one-time handshake yields a session `token`; each later `act` carries it +
+ *   the plaintext wire.
+ * - `encrypted` — same, but the wire is AES-GCM ciphertext, base64 in the `c` field.
+ *
+ * The handshake runs as two `hs` exchanges (hello→welcome, prove→accept) correlated by a client-chosen
+ * `hsid`, since stateless requests can't rely on channel ordering. The `accept` reply carries the token.
+ */
+type TWireJson = TActionPayload_Any_JsonObject<any, any>;
+/** Connector → acceptor request envelope. */
+type TExchangeRequest = {
+  k: "hs";
+  hsid: string;
+  m: string;
+} | {
+  k: "act";
+  t?: string;
+  w: TWireJson;
+} | {
+  k: "act";
+  t?: string;
+  c: string;
+};
+/** Acceptor → connector reply envelope. */
+type TExchangeReply = {
+  k: "hs";
+  m: string;
+  t?: string;
+} | {
+  k: "act";
+  w: TWireJson;
+} | {
+  k: "act";
+  c: string;
+} | {
+  k: "err";
+  message: string;
+};
+declare function encodeExchange(envelope: TExchangeRequest | TExchangeReply): string;
+declare function decodeExchangeRequest(raw: string): TExchangeRequest | undefined;
+declare function decodeExchangeReply(raw: string): TExchangeReply | undefined;
+//#endregion
 //#region src/errors/err_nice_action.d.ts
 declare enum EErrId_NiceAction {
   not_implemented = "not_implemented",
@@ -2646,11 +2745,13 @@ declare class ActionRuntime {
    * Used to locate the return-path channel for dispatching results back to the action origin.
    * Returns `undefined` if no handler matches (score > 0 required, i.e. at least id must match).
    *
-   * A handler that currently holds the origin's *live* connection always wins over a mere coordinate
-   * match — so with several duplex acceptors (e.g. WS + WebRTC) a result/push routes back over the carrier
-   * the client actually connected on, never a same-coordinate sibling that lacks the socket. Only when no
-   * handler owns a live connection do we fall back to the plain best-coordinate-score pick (the
-   * single-acceptor and connector-only cases, unchanged).
+   * A handler that currently holds the origin's *live* connection always wins, regardless of its
+   * coordinate score — owning the live socket bound to the origin's exact coordinate (set from the
+   * handshake) is a strictly more precise match than any env-level `peerClient` score. This lets one
+   * server accept clients of *several* envs over a single acceptor (a multi-role Durable Object): the
+   * result/push routes back over the carrier the client actually connected on even when the handler's
+   * `clientEnv` is unset or names a different env. Only when no handler owns a live connection do we fall
+   * back to the plain best-coordinate-score pick (the offline-return and connector-only cases).
    */
   getReturnHandlerForOrigin(originClient: RuntimeCoordinate): PeerLinkHandler | undefined;
   resetRuntime(): void;
@@ -2788,11 +2889,13 @@ interface IAcceptorSecurity {
 }
 interface IAcceptorHandlerBaseOptions<TConn> {
   /**
-   * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`).
-   * The runtime's return-path dispatch scores incoming actions' `originClient` against this to pick
-   * this handler for sending results/pushes back over the right channel.
+   * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
+   * scored against an action's `originClient` to pick this handler when *no* handler holds the client's
+   * live connection (the offline-return fallback). A handler that currently owns the live socket always
+   * wins regardless, so this is optional: omit it for a multi-role server that accepts several client envs
+   * over one acceptor — it then defaults to `RuntimeCoordinate.unknown` (scores 0 against every client).
    */
-  clientEnv: RuntimeCoordinate;
+  clientEnv?: RuntimeCoordinate;
   /** Write an encoded frame to a specific live connection (e.g. `(ws, frame) => ws.send(frame)`). */
   send: (connection: TConn, frame: string | Uint8Array | ArrayBuffer) => void;
   /**
@@ -2993,5 +3096,5 @@ declare class AcceptorHandler<TConn = unknown> extends PeerLinkHandler {
 }
 declare const createAcceptorHandler: <TConn = unknown>(options: IAcceptorHandlerOptions<TConn>) => AcceptorHandler<TConn>;
 //#endregion
-export { rtcCarrier as $, MaybePromise as $n, IActionTransportInitialized as $t, TActionResultOutcome as A, TransportConnection as An, TInferOutputFromSchema as Ar, IConnectChannelOptions as At, IHttpCarrierOptions as B, IHandshakeEncryptionKeyMaterial as Bn, IActionWireFormat as Bt, IActionProgress_Custom as C, TSendActionDataMethod as Cn, IActionDomain as Cr, createHibernatableWsServerAdapter as Ct, TActionPayload_Any_Instance as D, TTransportStatusInfo as Dn, TActionDomainSchema as Dr, createConnectionStateStore as Dt, IActionRouteItemHandler as E, TTransportInitializationFinishedInfo as En, TActionDomainChildDef as Er, IConnectionStateStoreOptions as Et, decodeActionFrame as F, EHandshakeMessageType as Fn, TInferActionError as Fr, acceptChannelConnections as Ft, httpAcceptorCarrier as G, createInMemoryTofuVerifyKeyResolver as Gn, TCarrier as Gt, TCarrierFetch as H, IServerHandshakeConfig as Hn, IDuplexCarrierSource as Ht, EErrId_NiceAction as I, ESecurityLevel as In, actionSchema as Ir, connectChannel as It, IWsAcceptorCarrierOptions as J, decodeHandshakeMessage as Jn, createConnectorHandler as Jt, IWsCarrierOptions as K, createServerHandshake as Kn, TFrame$1 as Kt, err_nice_action as L, IClientHandshakeConfig as Ln, TActionSchemaOptions as Lr, defineChannel as Lt, isActionPayload_Request_JsonObject as M, Transport as Mn, TPossibleDomainIdList as Mr, TChannelAcceptorCases as Mt, isActionPayload_Any_JsonObject as N, ISecureAcceptorHandlerOptions as Nn, ActionSchema as Nr, TChannelPushHandlers as Nt, TActionPayload_Any_JsonObject as O, TTransportStatusInfo_GetTransport_Output as On, TDomainActionId as Or, IAcceptChannelOptions as Ot, IActionFrameDecoder as P, createSecureAcceptorHandler as Pn, EActionResponseMode as Pr, acceptChannel as Pt, IRtcCarrierOptions as Q, createLocalHandler as Qn, IActionTransportDef as Qt, EErrId_NiceTransport as R, IClientVerifyKeyResolveInput as Rn, TActionSerializationDefinition as Rr, IBinaryWireSessionOptions as Rt, IActionPayload_Result_JsonObject as S, TOnResolveIncomingResponseJson as Sn, IActionCore_JsonObject as Sr, IHibernatableWsServerAdapterOptions as St, IActionProgress_Percentage as T, TTransportCache as Tn, IActionRootDomain as Tr, IConnectionAttachment as Tt, httpCarrier as U, THandshakeMessage as Un, IExchangeCarrier as Ut, IHttpCarrierRequest as V, IHandshakeResult as Vn, IDuplexCarrier as Vt, IHttpAcceptorCarrierOptions as W, createClientHandshake as Wn, IExchangeCarrierSource as Wt, EErrId_NiceTransport_WebSocket as X, runtimeLinkId as Xn, ETransportShape as Xt, wsAcceptorCarrier as Y, encodeHandshakeMessage as Yn, PeerLinkHandler as Yt, err_nice_transport_ws as Z, ActionLocalHandler as Zn, ETransportStatus as Zt, IActionPayload_Data_Base as _, TOnResolveAnyIncomingActionData as _n, IRuntimeFullCoordinates as _r, IDuplexAcceptorCarrier as _t, TAcceptorConnectionCaseFn as a, ITransportDispatchAction as an, ERunningActionUpdateType as ar, IInMemoryServerEndpoint as at, IActionPayload_Request_JsonObject as b, TOnResolveIncomingRequestJson as bn, TRuntimeCoordinateStringId as br, isExchangeAcceptorCarrier as bt, createAcceptorHandler as c, ITransportRouteClientParams as cn, IRunningActionUpdate_Started as cr, IChannelHostAdapter as ct, ActionCore as d, ITransportStatusInfo_Failed as dn, TRunningActionUpdateFinished as dr, IChannelServer as dt, IActionTransportReady as en, createActionRootDomain as er, IRtcDataChannelLike as et, ActionPayload_Request as f, ITransportStatusInfo_Initializing as fn, TRunningActionUpdateListener as fr, IConnectionContext as ft, IActionPayload_Base_JsonObject as g, TGetTransportFn as gn, IRuntimeCoordinateSpecifics as gr, IAcceptorAttachmentStore as gt, IActionPayload_Base as h, IUpdateActionRunConfig_Output as hn, IRuntimeCoordinate as hr, serveChannel as ht, TAcceptorCaseFn as i, ISecureClientConfig as in, ERunningActionState as ir, IInMemoryChannelPair as it, isActionPayload_Result_JsonObject as j, ITransportConnectionContext as jn, TPossibleDomainId as jr, IConnectTransport as jt, TActionProgress as k, TUpdateActionRunConfig as kn, TInferInputFromSchema as kr, IActionChannel as kt, ActionDomain as l, ITransportRouteInfo as ln, IRunningActionUpdate_Success as lr, TServeHostOptions as lt, EActionProgressType as m, ITransportStatusInfo_Unsupported as mn, ActionPayload_Progress as mr, IServeConnectionStateOptions as mt, IAcceptorConnectionBinding as n, IActionTransportReadyData_Methods as nn, RunningAction as nr, IInMemoryCarrier as nt, TActionChannelFormatMessage as o, ITransportMethod_SendActionData_Input as on, IRunningActionUpdate_Abort as or, createInMemoryChannelPair as ot, EActionPayloadType as p, ITransportStatusInfo_Ready as pn, ActionPayload_Result as pr, IServeChannelOptions as pt, wsCarrier as q, createStorageTofuVerifyKeyResolver as qn, ConnectorHandler as qt, IAcceptorHandlerOptions as r, IActionTransportResolvers as rn, ERunningActionFinishedType as rr, inMemoryCarrier as rt, TActionConnectionEncoding as s, ITransportRouteActionParams as sn, IRunningActionUpdate_Progress as sr, err_nice_external_client as st, AcceptorHandler as t, IActionTransportReadyData_Base as tn, ActionRootDomain as tr, rtcDataChannelByteChannel as tt, ActionRuntime as u, ITransportStatusInfo_Base as un, TRunningActionUpdate as ur, serveHost as ut, IActionPayload_Progress as v, TOnResolveAnyIncomingActionData_Json as vn, RuntimeCoordinate as vr, IExchangeAcceptorCarrier as vt, IActionProgress_None as w, TSendReturnDataMethod as wn, IActionDomainChildOptions as wr, ConnectionStateStore as wt, IActionPayload_Result as x, TOnResolveIncomingResponse as xn, IActionCore as xr, IDuplexConnectionRouter as xt, IActionPayload_Progress_JsonObject as y, TOnResolveIncomingRequest as yn, TRuntimeCoordinateEnvId as yr, TAcceptorCarrier as yt, err_nice_transport as z, IClientVerifyKeyResolver as zn, TTransportedValue as zr, createBinaryWireSessionFactory as zt };
-//# sourceMappingURL=AcceptorHandler-11-QMdx2.d.mts.map
+export { httpAcceptorCarrier as $, createInMemoryTofuVerifyKeyResolver as $n, TCarrier as $t, TActionResultOutcome as A, TOnResolveIncomingResponseJson as An, IActionCore_JsonObject as Ar, IHibernatableWsServerAdapterOptions as At, decodeExchangeReply as B, Transport as Bn, TPossibleDomainIdList as Br, TChannelAcceptorCases as Bt, IActionProgress_Custom as C, IUpdateActionRunConfig_Output as Cn, IRuntimeCoordinate as Cr, serveChannel as Ct, TActionPayload_Any_Instance as D, TOnResolveIncomingRequest as Dn, TRuntimeCoordinateEnvId as Dr, TAcceptorCarrier as Dt, IActionRouteItemHandler as E, TOnResolveAnyIncomingActionData_Json as En, RuntimeCoordinate as Er, IExchangeAcceptorCarrier as Et, decodeActionFrame as F, TTransportStatusInfo as Fn, TActionDomainSchema as Fr, createConnectionStateStore as Ft, IExchangeAcceptorSecurity as G, IClientHandshakeConfig as Gn, TActionSchemaOptions as Gr, defineChannel as Gt, encodeExchange as H, createSecureAcceptorHandler as Hn, EActionResponseMode as Hr, acceptChannel as Ht, EErrId_NiceAction as I, TTransportStatusInfo_GetTransport_Output as In, TDomainActionId as Ir, IAcceptChannelOptions as It, IHttpCarrierOptions as J, IHandshakeEncryptionKeyMaterial as Jn, IActionWireFormat as Jt, EErrId_NiceTransport as K, IClientVerifyKeyResolveInput as Kn, TActionSerializationDefinition as Kr, IBinaryWireSessionOptions as Kt, err_nice_action as L, TUpdateActionRunConfig as Ln, TInferInputFromSchema as Lr, IActionChannel as Lt, isActionPayload_Request_JsonObject as M, TSendReturnDataMethod as Mn, IActionDomainChildOptions as Mr, ConnectionStateStore as Mt, isActionPayload_Any_JsonObject as N, TTransportCache as Nn, IActionRootDomain as Nr, IConnectionAttachment as Nt, TActionPayload_Any_JsonObject as O, TOnResolveIncomingRequestJson as On, TRuntimeCoordinateStringId as Or, isExchangeAcceptorCarrier as Ot, IActionFrameDecoder as P, TTransportInitializationFinishedInfo as Pn, TActionDomainChildDef as Pr, IConnectionStateStoreOptions as Pt, IHttpAcceptorCarrierOptions as Q, createClientHandshake as Qn, IExchangeCarrierSource as Qt, TExchangeReply as R, TransportConnection as Rn, TInferOutputFromSchema as Rr, IConnectChannelOptions as Rt, IActionPayload_Result_JsonObject as S, ITransportStatusInfo_Unsupported as Sn, ActionPayload_Progress as Sr, IServeConnectionStateOptions as St, IActionProgress_Percentage as T, TOnResolveAnyIncomingActionData as Tn, IRuntimeFullCoordinates as Tr, IDuplexAcceptorCarrier as Tt, ExchangeAcceptor as U, EHandshakeMessageType as Un, TInferActionError as Ur, acceptChannelConnections as Ut, decodeExchangeRequest as V, ISecureAcceptorHandlerOptions as Vn, ActionSchema as Vr, TChannelPushHandlers as Vt, IExchangeAcceptorConfig as W, ESecurityLevel as Wn, actionSchema as Wr, connectChannel as Wt, TCarrierFetch as X, IServerHandshakeConfig as Xn, IDuplexCarrierSource as Xt, IHttpCarrierRequest as Y, IHandshakeResult as Yn, IDuplexCarrier as Yt, httpCarrier as Z, THandshakeMessage as Zn, IExchangeCarrier as Zt, IActionPayload_Data_Base as _, ITransportRouteInfo as _n, IRunningActionUpdate_Success as _r, TServeHostOptions as _t, TAcceptorConnectionCaseFn as a, ETransportStatus as an, ActionLocalHandler as ar, err_nice_transport_ws as at, IActionPayload_Request_JsonObject as b, ITransportStatusInfo_Initializing as bn, TRunningActionUpdateListener as br, IConnectionContext as bt, createAcceptorHandler as c, IActionTransportReady as cn, createActionRootDomain as cr, IRtcDataChannelLike as ct, ActionCore as d, IActionTransportResolvers as dn, ERunningActionFinishedType as dr, inMemoryCarrier as dt, TFrame$1 as en, createServerHandshake as er, IWsCarrierOptions as et, ActionPayload_Request as f, ISecureClientConfig as fn, ERunningActionState as fr, IInMemoryChannelPair as ft, IActionPayload_Base_JsonObject as g, ITransportRouteClientParams as gn, IRunningActionUpdate_Started as gr, IChannelHostAdapter as gt, IActionPayload_Base as h, ITransportRouteActionParams as hn, IRunningActionUpdate_Progress as hr, err_nice_external_client as ht, TAcceptorCaseFn as i, ETransportShape as in, runtimeLinkId as ir, EErrId_NiceTransport_WebSocket as it, isActionPayload_Result_JsonObject as j, TSendActionDataMethod as jn, IActionDomain as jr, createHibernatableWsServerAdapter as jt, TActionProgress as k, TOnResolveIncomingResponse as kn, IActionCore as kr, IDuplexConnectionRouter as kt, ActionDomain as l, IActionTransportReadyData_Base as ln, ActionRootDomain as lr, rtcDataChannelByteChannel as lt, EActionProgressType as m, ITransportMethod_SendActionData_Input as mn, IRunningActionUpdate_Abort as mr, createInMemoryChannelPair as mt, IAcceptorConnectionBinding as n, createConnectorHandler as nn, decodeHandshakeMessage as nr, IWsAcceptorCarrierOptions as nt, TActionChannelFormatMessage as o, IActionTransportDef as on, createLocalHandler as or, IRtcCarrierOptions as ot, EActionPayloadType as p, ITransportDispatchAction as pn, ERunningActionUpdateType as pr, IInMemoryServerEndpoint as pt, err_nice_transport as q, IClientVerifyKeyResolver as qn, TTransportedValue as qr, createBinaryWireSessionFactory as qt, IAcceptorHandlerOptions as r, PeerLinkHandler as rn, encodeHandshakeMessage as rr, wsAcceptorCarrier as rt, TActionConnectionEncoding as s, IActionTransportInitialized as sn, MaybePromise as sr, rtcCarrier as st, AcceptorHandler as t, ConnectorHandler as tn, createStorageTofuVerifyKeyResolver as tr, wsCarrier as tt, ActionRuntime as u, IActionTransportReadyData_Methods as un, RunningAction as ur, IInMemoryCarrier as ut, IActionPayload_Progress as v, ITransportStatusInfo_Base as vn, TRunningActionUpdate as vr, serveHost as vt, IActionProgress_None as w, TGetTransportFn as wn, IRuntimeCoordinateSpecifics as wr, IAcceptorAttachmentStore as wt, IActionPayload_Result as x, ITransportStatusInfo_Ready as xn, ActionPayload_Result as xr, IServeChannelOptions as xt, IActionPayload_Progress_JsonObject as y, ITransportStatusInfo_Failed as yn, TRunningActionUpdateFinished as yr, IChannelServer as yt, TExchangeRequest as z, ITransportConnectionContext as zn, TPossibleDomainId as zr, IConnectTransport as zt };
+//# sourceMappingURL=AcceptorHandler-BizUtq4u.d.mts.map

package/build/{AcceptorHandler-CxD0c1BE.d.cts → AcceptorHandler-CxPfZtIl.d.cts}

@@ -820,9 +820,10 @@ interface ISecureAcceptorHandlerOptions<TConn> {
   channel: IActionChannel;
   /**
    * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
-   * used to route results/pushes back over this handler.
+   * used as the offline-return scoring fallback (a live connection always wins regardless). Optional —
+   * omit it for a multi-role server accepting several client envs over one acceptor.
    */
-  clientEnv: RuntimeCoordinate;
+  clientEnv?: RuntimeCoordinate;
   /** This server's runtime — its coordinate is the server identity presented in the handshake. */
   runtime: ActionRuntime;
   /**
@@ -1832,9 +1833,12 @@ interface IConnectionContext<TConn, TApp = unknown> {
 interface IServeChannelOptions<TO_ACCEPTOR extends readonly ActionDomain<any>[], TConn, TApp = unknown> {
   /**
    * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
-   * used to score return-path dispatch back to the right connection.
+   * used only as the offline-return scoring fallback — a result/push to a live client always routes over
+   * the carrier it connected on regardless of this. Optional: omit it for a multi-role server that accepts
+   * clients of several envs over one acceptor (it then scores 0 against every client, so the live
+   * connection always decides).
    */
-  clientEnv: RuntimeCoordinate;
+  clientEnv?: RuntimeCoordinate;
   /**
    * One backing store for the server's crypto identity *and* its trust-on-first-use verify-key pins
    * (their keys don't collide). It is built once and shared across every carrier, so the WebSocket and the
@@ -2265,6 +2269,101 @@ declare const err_nice_transport: import("@nice-code/error").NiceErrorDomain<{
   };
 }>;
 //#endregion
+//#region src/ActionRuntime/Transport/SecureSession/exchangeAcceptor.d.ts
+/** Acceptor secure config for the exchange (HTTP) endpoint — same identity an `AcceptorHandler` uses. */
+interface IExchangeAcceptorSecurity {
+  /** This acceptor's crypto identity (verify + exchange key pairs, optionally persisted). */
+  link: ClientCryptoKeyLink;
+  /** This acceptor's coordinate — its identity to clients during the handshake. */
+  localCoordinate: IRuntimeCoordinate;
+  /** Wire dictionary version; the handshake rejects a client on a mismatch. */
+  dictionaryVersion: string;
+  /** Accepted level(s) — a single level is strict, an array is a negotiable allowed set. */
+  securityLevel: ESecurityLevel | readonly ESecurityLevel[];
+  /** Trust decision for a client's verify key (defaults to in-memory TOFU inside the handshake). */
+  verifyKeyResolver?: IClientVerifyKeyResolver;
+}
+interface IExchangeAcceptorConfig {
+  security: IExchangeAcceptorSecurity;
+  /** The runtime that executes an inbound action wire and produces its result. */
+  runtime: ActionRuntime;
+}
+/**
+ * Acceptor (accept-in) side of the secure exchange protocol — the HTTP counterpart to
+ * {@link AcceptorSecureSession}. Each POST body is one {@link decodeExchangeRequest} envelope; the
+ * acceptor drives the server handshake over the two `hs` POSTs (correlated by `hsid`, since stateless
+ * requests can't rely on channel ordering), mints a session **token** on accept, and on every later `act`
+ * POST resolves the session by token, decrypts the body (at `encrypted`), routes it through the runtime,
+ * and returns the (encrypted) result inline as the reply.
+ *
+ * Sessions and in-flight handshakes are held in memory — fine for a single-instance server. (Surviving a
+ * Durable-Object eviction would persist each token's `keyMaterial` and re-derive the key on a miss, the
+ * same primitive `AcceptorSecureSession.rehydrate` uses; left as a follow-up.)
+ */
+declare class ExchangeAcceptor {
+  private readonly _security;
+  private readonly _runtime;
+  private readonly _allowedLevels;
+  private readonly _noneAllowed;
+  private readonly _pendingHandshakes;
+  private readonly _sessions;
+  constructor(config: IExchangeAcceptorConfig);
+  /** Process one POST body (an exchange envelope), returning the reply body to send back. */
+  handlePost(body: string): Promise<string>;
+  private _handleHandshake;
+  private _handleAction;
+  private _err;
+}
+//#endregion
+//#region src/ActionRuntime/Transport/SecureSession/exchangeProtocol.d.ts
+/**
+ * The application-level envelope for secure action traffic over an {@link IExchangeCarrier} (HTTP). An
+ * exchange carrier only moves one request frame → one reply frame with no unsolicited push, so the
+ * handshake and the per-action token + crypto all ride in this envelope (a JSON string body) rather than
+ * on a persistent channel. The three security levels share it:
+ *
+ * - `none` — no handshake, no token: an `act` envelope carries the plaintext wire both ways.
+ * - `authenticated` — a one-time handshake yields a session `token`; each later `act` carries it +
+ *   the plaintext wire.
+ * - `encrypted` — same, but the wire is AES-GCM ciphertext, base64 in the `c` field.
+ *
+ * The handshake runs as two `hs` exchanges (hello→welcome, prove→accept) correlated by a client-chosen
+ * `hsid`, since stateless requests can't rely on channel ordering. The `accept` reply carries the token.
+ */
+type TWireJson = TActionPayload_Any_JsonObject<any, any>;
+/** Connector → acceptor request envelope. */
+type TExchangeRequest = {
+  k: "hs";
+  hsid: string;
+  m: string;
+} | {
+  k: "act";
+  t?: string;
+  w: TWireJson;
+} | {
+  k: "act";
+  t?: string;
+  c: string;
+};
+/** Acceptor → connector reply envelope. */
+type TExchangeReply = {
+  k: "hs";
+  m: string;
+  t?: string;
+} | {
+  k: "act";
+  w: TWireJson;
+} | {
+  k: "act";
+  c: string;
+} | {
+  k: "err";
+  message: string;
+};
+declare function encodeExchange(envelope: TExchangeRequest | TExchangeReply): string;
+declare function decodeExchangeRequest(raw: string): TExchangeRequest | undefined;
+declare function decodeExchangeReply(raw: string): TExchangeReply | undefined;
+//#endregion
 //#region src/errors/err_nice_action.d.ts
 declare enum EErrId_NiceAction {
   not_implemented = "not_implemented",
@@ -2646,11 +2745,13 @@ declare class ActionRuntime {
    * Used to locate the return-path channel for dispatching results back to the action origin.
    * Returns `undefined` if no handler matches (score > 0 required, i.e. at least id must match).
    *
-   * A handler that currently holds the origin's *live* connection always wins over a mere coordinate
-   * match — so with several duplex acceptors (e.g. WS + WebRTC) a result/push routes back over the carrier
-   * the client actually connected on, never a same-coordinate sibling that lacks the socket. Only when no
-   * handler owns a live connection do we fall back to the plain best-coordinate-score pick (the
-   * single-acceptor and connector-only cases, unchanged).
+   * A handler that currently holds the origin's *live* connection always wins, regardless of its
+   * coordinate score — owning the live socket bound to the origin's exact coordinate (set from the
+   * handshake) is a strictly more precise match than any env-level `peerClient` score. This lets one
+   * server accept clients of *several* envs over a single acceptor (a multi-role Durable Object): the
+   * result/push routes back over the carrier the client actually connected on even when the handler's
+   * `clientEnv` is unset or names a different env. Only when no handler owns a live connection do we fall
+   * back to the plain best-coordinate-score pick (the offline-return and connector-only cases).
    */
   getReturnHandlerForOrigin(originClient: RuntimeCoordinate): PeerLinkHandler | undefined;
   resetRuntime(): void;
@@ -2788,11 +2889,13 @@ interface IAcceptorSecurity {
 }
 interface IAcceptorHandlerBaseOptions<TConn> {
   /**
-   * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`).
-   * The runtime's return-path dispatch scores incoming actions' `originClient` against this to pick
-   * this handler for sending results/pushes back over the right channel.
+   * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
+   * scored against an action's `originClient` to pick this handler when *no* handler holds the client's
+   * live connection (the offline-return fallback). A handler that currently owns the live socket always
+   * wins regardless, so this is optional: omit it for a multi-role server that accepts several client envs
+   * over one acceptor — it then defaults to `RuntimeCoordinate.unknown` (scores 0 against every client).
    */
-  clientEnv: RuntimeCoordinate;
+  clientEnv?: RuntimeCoordinate;
   /** Write an encoded frame to a specific live connection (e.g. `(ws, frame) => ws.send(frame)`). */
   send: (connection: TConn, frame: string | Uint8Array | ArrayBuffer) => void;
   /**
@@ -2993,5 +3096,5 @@ declare class AcceptorHandler<TConn = unknown> extends PeerLinkHandler {
 }
 declare const createAcceptorHandler: <TConn = unknown>(options: IAcceptorHandlerOptions<TConn>) => AcceptorHandler<TConn>;
 //#endregion
-export { rtcCarrier as $, MaybePromise as $n, IActionTransportInitialized as $t, TActionResultOutcome as A, TransportConnection as An, TInferOutputFromSchema as Ar, IConnectChannelOptions as At, IHttpCarrierOptions as B, IHandshakeEncryptionKeyMaterial as Bn, IActionWireFormat as Bt, IActionProgress_Custom as C, TSendActionDataMethod as Cn, IActionDomain as Cr, createHibernatableWsServerAdapter as Ct, TActionPayload_Any_Instance as D, TTransportStatusInfo as Dn, TActionDomainSchema as Dr, createConnectionStateStore as Dt, IActionRouteItemHandler as E, TTransportInitializationFinishedInfo as En, TActionDomainChildDef as Er, IConnectionStateStoreOptions as Et, decodeActionFrame as F, EHandshakeMessageType as Fn, TInferActionError as Fr, acceptChannelConnections as Ft, httpAcceptorCarrier as G, createInMemoryTofuVerifyKeyResolver as Gn, TCarrier as Gt, TCarrierFetch as H, IServerHandshakeConfig as Hn, IDuplexCarrierSource as Ht, EErrId_NiceAction as I, ESecurityLevel as In, actionSchema as Ir, connectChannel as It, IWsAcceptorCarrierOptions as J, decodeHandshakeMessage as Jn, createConnectorHandler as Jt, IWsCarrierOptions as K, createServerHandshake as Kn, TFrame$1 as Kt, err_nice_action as L, IClientHandshakeConfig as Ln, TActionSchemaOptions as Lr, defineChannel as Lt, isActionPayload_Request_JsonObject as M, Transport as Mn, TPossibleDomainIdList as Mr, TChannelAcceptorCases as Mt, isActionPayload_Any_JsonObject as N, ISecureAcceptorHandlerOptions as Nn, ActionSchema as Nr, TChannelPushHandlers as Nt, TActionPayload_Any_JsonObject as O, TTransportStatusInfo_GetTransport_Output as On, TDomainActionId as Or, IAcceptChannelOptions as Ot, IActionFrameDecoder as P, createSecureAcceptorHandler as Pn, EActionResponseMode as Pr, acceptChannel as Pt, IRtcCarrierOptions as Q, createLocalHandler as Qn, IActionTransportDef as Qt, EErrId_NiceTransport as R, IClientVerifyKeyResolveInput as Rn, TActionSerializationDefinition as Rr, IBinaryWireSessionOptions as Rt, IActionPayload_Result_JsonObject as S, TOnResolveIncomingResponseJson as Sn, IActionCore_JsonObject as Sr, IHibernatableWsServerAdapterOptions as St, IActionProgress_Percentage as T, TTransportCache as Tn, IActionRootDomain as Tr, IConnectionAttachment as Tt, httpCarrier as U, THandshakeMessage as Un, IExchangeCarrier as Ut, IHttpCarrierRequest as V, IHandshakeResult as Vn, IDuplexCarrier as Vt, IHttpAcceptorCarrierOptions as W, createClientHandshake as Wn, IExchangeCarrierSource as Wt, EErrId_NiceTransport_WebSocket as X, runtimeLinkId as Xn, ETransportShape as Xt, wsAcceptorCarrier as Y, encodeHandshakeMessage as Yn, PeerLinkHandler as Yt, err_nice_transport_ws as Z, ActionLocalHandler as Zn, ETransportStatus as Zt, IActionPayload_Data_Base as _, TOnResolveAnyIncomingActionData as _n, IRuntimeFullCoordinates as _r, IDuplexAcceptorCarrier as _t, TAcceptorConnectionCaseFn as a, ITransportDispatchAction as an, ERunningActionUpdateType as ar, IInMemoryServerEndpoint as at, IActionPayload_Request_JsonObject as b, TOnResolveIncomingRequestJson as bn, TRuntimeCoordinateStringId as br, isExchangeAcceptorCarrier as bt, createAcceptorHandler as c, ITransportRouteClientParams as cn, IRunningActionUpdate_Started as cr, IChannelHostAdapter as ct, ActionCore as d, ITransportStatusInfo_Failed as dn, TRunningActionUpdateFinished as dr, IChannelServer as dt, IActionTransportReady as en, createActionRootDomain as er, IRtcDataChannelLike as et, ActionPayload_Request as f, ITransportStatusInfo_Initializing as fn, TRunningActionUpdateListener as fr, IConnectionContext as ft, IActionPayload_Base_JsonObject as g, TGetTransportFn as gn, IRuntimeCoordinateSpecifics as gr, IAcceptorAttachmentStore as gt, IActionPayload_Base as h, IUpdateActionRunConfig_Output as hn, IRuntimeCoordinate as hr, serveChannel as ht, TAcceptorCaseFn as i, ISecureClientConfig as in, ERunningActionState as ir, IInMemoryChannelPair as it, isActionPayload_Result_JsonObject as j, ITransportConnectionContext as jn, TPossibleDomainId as jr, IConnectTransport as jt, TActionProgress as k, TUpdateActionRunConfig as kn, TInferInputFromSchema as kr, IActionChannel as kt, ActionDomain as l, ITransportRouteInfo as ln, IRunningActionUpdate_Success as lr, TServeHostOptions as lt, EActionProgressType as m, ITransportStatusInfo_Unsupported as mn, ActionPayload_Progress as mr, IServeConnectionStateOptions as mt, IAcceptorConnectionBinding as n, IActionTransportReadyData_Methods as nn, RunningAction as nr, IInMemoryCarrier as nt, TActionChannelFormatMessage as o, ITransportMethod_SendActionData_Input as on, IRunningActionUpdate_Abort as or, createInMemoryChannelPair as ot, EActionPayloadType as p, ITransportStatusInfo_Ready as pn, ActionPayload_Result as pr, IServeChannelOptions as pt, wsCarrier as q, createStorageTofuVerifyKeyResolver as qn, ConnectorHandler as qt, IAcceptorHandlerOptions as r, IActionTransportResolvers as rn, ERunningActionFinishedType as rr, inMemoryCarrier as rt, TActionConnectionEncoding as s, ITransportRouteActionParams as sn, IRunningActionUpdate_Progress as sr, err_nice_external_client as st, AcceptorHandler as t, IActionTransportReadyData_Base as tn, ActionRootDomain as tr, rtcDataChannelByteChannel as tt, ActionRuntime as u, ITransportStatusInfo_Base as un, TRunningActionUpdate as ur, serveHost as ut, IActionPayload_Progress as v, TOnResolveAnyIncomingActionData_Json as vn, RuntimeCoordinate as vr, IExchangeAcceptorCarrier as vt, IActionProgress_None as w, TSendReturnDataMethod as wn, IActionDomainChildOptions as wr, ConnectionStateStore as wt, IActionPayload_Result as x, TOnResolveIncomingResponse as xn, IActionCore as xr, IDuplexConnectionRouter as xt, IActionPayload_Progress_JsonObject as y, TOnResolveIncomingRequest as yn, TRuntimeCoordinateEnvId as yr, TAcceptorCarrier as yt, err_nice_transport as z, IClientVerifyKeyResolver as zn, TTransportedValue as zr, createBinaryWireSessionFactory as zt };
-//# sourceMappingURL=AcceptorHandler-CxD0c1BE.d.cts.map
+export { httpAcceptorCarrier as $, createInMemoryTofuVerifyKeyResolver as $n, TCarrier as $t, TActionResultOutcome as A, TOnResolveIncomingResponseJson as An, IActionCore_JsonObject as Ar, IHibernatableWsServerAdapterOptions as At, decodeExchangeReply as B, Transport as Bn, TPossibleDomainIdList as Br, TChannelAcceptorCases as Bt, IActionProgress_Custom as C, IUpdateActionRunConfig_Output as Cn, IRuntimeCoordinate as Cr, serveChannel as Ct, TActionPayload_Any_Instance as D, TOnResolveIncomingRequest as Dn, TRuntimeCoordinateEnvId as Dr, TAcceptorCarrier as Dt, IActionRouteItemHandler as E, TOnResolveAnyIncomingActionData_Json as En, RuntimeCoordinate as Er, IExchangeAcceptorCarrier as Et, decodeActionFrame as F, TTransportStatusInfo as Fn, TActionDomainSchema as Fr, createConnectionStateStore as Ft, IExchangeAcceptorSecurity as G, IClientHandshakeConfig as Gn, TActionSchemaOptions as Gr, defineChannel as Gt, encodeExchange as H, createSecureAcceptorHandler as Hn, EActionResponseMode as Hr, acceptChannel as Ht, EErrId_NiceAction as I, TTransportStatusInfo_GetTransport_Output as In, TDomainActionId as Ir, IAcceptChannelOptions as It, IHttpCarrierOptions as J, IHandshakeEncryptionKeyMaterial as Jn, IActionWireFormat as Jt, EErrId_NiceTransport as K, IClientVerifyKeyResolveInput as Kn, TActionSerializationDefinition as Kr, IBinaryWireSessionOptions as Kt, err_nice_action as L, TUpdateActionRunConfig as Ln, TInferInputFromSchema as Lr, IActionChannel as Lt, isActionPayload_Request_JsonObject as M, TSendReturnDataMethod as Mn, IActionDomainChildOptions as Mr, ConnectionStateStore as Mt, isActionPayload_Any_JsonObject as N, TTransportCache as Nn, IActionRootDomain as Nr, IConnectionAttachment as Nt, TActionPayload_Any_JsonObject as O, TOnResolveIncomingRequestJson as On, TRuntimeCoordinateStringId as Or, isExchangeAcceptorCarrier as Ot, IActionFrameDecoder as P, TTransportInitializationFinishedInfo as Pn, TActionDomainChildDef as Pr, IConnectionStateStoreOptions as Pt, IHttpAcceptorCarrierOptions as Q, createClientHandshake as Qn, IExchangeCarrierSource as Qt, TExchangeReply as R, TransportConnection as Rn, TInferOutputFromSchema as Rr, IConnectChannelOptions as Rt, IActionPayload_Result_JsonObject as S, ITransportStatusInfo_Unsupported as Sn, ActionPayload_Progress as Sr, IServeConnectionStateOptions as St, IActionProgress_Percentage as T, TOnResolveAnyIncomingActionData as Tn, IRuntimeFullCoordinates as Tr, IDuplexAcceptorCarrier as Tt, ExchangeAcceptor as U, EHandshakeMessageType as Un, TInferActionError as Ur, acceptChannelConnections as Ut, decodeExchangeRequest as V, ISecureAcceptorHandlerOptions as Vn, ActionSchema as Vr, TChannelPushHandlers as Vt, IExchangeAcceptorConfig as W, ESecurityLevel as Wn, actionSchema as Wr, connectChannel as Wt, TCarrierFetch as X, IServerHandshakeConfig as Xn, IDuplexCarrierSource as Xt, IHttpCarrierRequest as Y, IHandshakeResult as Yn, IDuplexCarrier as Yt, httpCarrier as Z, THandshakeMessage as Zn, IExchangeCarrier as Zt, IActionPayload_Data_Base as _, ITransportRouteInfo as _n, IRunningActionUpdate_Success as _r, TServeHostOptions as _t, TAcceptorConnectionCaseFn as a, ETransportStatus as an, ActionLocalHandler as ar, err_nice_transport_ws as at, IActionPayload_Request_JsonObject as b, ITransportStatusInfo_Initializing as bn, TRunningActionUpdateListener as br, IConnectionContext as bt, createAcceptorHandler as c, IActionTransportReady as cn, createActionRootDomain as cr, IRtcDataChannelLike as ct, ActionCore as d, IActionTransportResolvers as dn, ERunningActionFinishedType as dr, inMemoryCarrier as dt, TFrame$1 as en, createServerHandshake as er, IWsCarrierOptions as et, ActionPayload_Request as f, ISecureClientConfig as fn, ERunningActionState as fr, IInMemoryChannelPair as ft, IActionPayload_Base_JsonObject as g, ITransportRouteClientParams as gn, IRunningActionUpdate_Started as gr, IChannelHostAdapter as gt, IActionPayload_Base as h, ITransportRouteActionParams as hn, IRunningActionUpdate_Progress as hr, err_nice_external_client as ht, TAcceptorCaseFn as i, ETransportShape as in, runtimeLinkId as ir, EErrId_NiceTransport_WebSocket as it, isActionPayload_Result_JsonObject as j, TSendActionDataMethod as jn, IActionDomain as jr, createHibernatableWsServerAdapter as jt, TActionProgress as k, TOnResolveIncomingResponse as kn, IActionCore as kr, IDuplexConnectionRouter as kt, ActionDomain as l, IActionTransportReadyData_Base as ln, ActionRootDomain as lr, rtcDataChannelByteChannel as lt, EActionProgressType as m, ITransportMethod_SendActionData_Input as mn, IRunningActionUpdate_Abort as mr, createInMemoryChannelPair as mt, IAcceptorConnectionBinding as n, createConnectorHandler as nn, decodeHandshakeMessage as nr, IWsAcceptorCarrierOptions as nt, TActionChannelFormatMessage as o, IActionTransportDef as on, createLocalHandler as or, IRtcCarrierOptions as ot, EActionPayloadType as p, ITransportDispatchAction as pn, ERunningActionUpdateType as pr, IInMemoryServerEndpoint as pt, err_nice_transport as q, IClientVerifyKeyResolver as qn, TTransportedValue as qr, createBinaryWireSessionFactory as qt, IAcceptorHandlerOptions as r, PeerLinkHandler as rn, encodeHandshakeMessage as rr, wsAcceptorCarrier as rt, TActionConnectionEncoding as s, IActionTransportInitialized as sn, MaybePromise as sr, rtcCarrier as st, AcceptorHandler as t, ConnectorHandler as tn, createStorageTofuVerifyKeyResolver as tr, wsCarrier as tt, ActionRuntime as u, IActionTransportReadyData_Methods as un, RunningAction as ur, IInMemoryCarrier as ut, IActionPayload_Progress as v, ITransportStatusInfo_Base as vn, TRunningActionUpdate as vr, serveHost as vt, IActionProgress_None as w, TGetTransportFn as wn, IRuntimeCoordinateSpecifics as wr, IAcceptorAttachmentStore as wt, IActionPayload_Result as x, ITransportStatusInfo_Ready as xn, ActionPayload_Result as xr, IServeChannelOptions as xt, IActionPayload_Progress_JsonObject as y, ITransportStatusInfo_Failed as yn, TRunningActionUpdateFinished as yr, IChannelServer as yt, TExchangeRequest as z, ITransportConnectionContext as zn, TPossibleDomainId as zr, IConnectTransport as zt };
+//# sourceMappingURL=AcceptorHandler-CxPfZtIl.d.cts.map

package/build/{ActionDevtoolsCore-37JP4bOG.d.cts → ActionDevtoolsCore-D9KBBI2V.d.cts}

@@ -1,4 +1,4 @@
-import { hr as IRuntimeCoordinate, k as TActionProgress } from "./AcceptorHandler-CxD0c1BE.cjs";
+import { Cr as IRuntimeCoordinate, k as TActionProgress } from "./AcceptorHandler-CxPfZtIl.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-37JP4bOG.d.cts.map
+//# sourceMappingURL=ActionDevtoolsCore-D9KBBI2V.d.cts.map

package/build/{ActionDevtoolsCore-Cgq-go1R.d.mts → ActionDevtoolsCore-xZjAtB4H.d.mts}

@@ -1,4 +1,4 @@
-import { hr as IRuntimeCoordinate, k as TActionProgress } from "./AcceptorHandler-11-QMdx2.mjs";
+import { Cr as IRuntimeCoordinate, k as TActionProgress } from "./AcceptorHandler-BizUtq4u.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-Cgq-go1R.d.mts.map
+//# sourceMappingURL=ActionDevtoolsCore-xZjAtB4H.d.mts.map

package/build/advanced/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_createHibernatableWsServerAdapter = require("../createHibernatableWsServerAdapter-BNi4k9j3.cjs");
+const require_createHibernatableWsServerAdapter = require("../createHibernatableWsServerAdapter-FSDWrxoF.cjs");
 let msgpackr = require("msgpackr");
 //#region src/ActionRuntime/Transport/codec/createBinaryWireAdapter.ts
 /**