@nice-code/action 0.19.0 → 0.20.0

package/build/{ActionDevtoolsCore-CCZXQBAo.d.cts → ActionDevtoolsCore-D_JvgPmz.d.mts}

@@ -1,4 +1,4 @@
-import { Ir as IRuntimeCoordinate, _ as TActionProgress } from "./ActionPayload.types-CdHOGGZK.cjs";
+import { Lr as IRuntimeCoordinate, _ as TActionProgress } from "./ActionPayload.types-D0DM-g65.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-CCZXQBAo.d.cts.map
+//# sourceMappingURL=ActionDevtoolsCore-D_JvgPmz.d.mts.map

package/build/{ActionDevtoolsCore-bjYQ8O2_.d.mts → ActionDevtoolsCore-dV-IVPcP.d.cts}

@@ -1,4 +1,4 @@
-import { Ir as IRuntimeCoordinate, _ as TActionProgress } from "./ActionPayload.types-Bmkzw2df.mjs";
+import { Lr as IRuntimeCoordinate, _ as TActionProgress } from "./ActionPayload.types-CnfWlkA1.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-bjYQ8O2_.d.mts.map
+//# sourceMappingURL=ActionDevtoolsCore-dV-IVPcP.d.cts.map

package/build/{ActionPayload.types-Bmkzw2df.d.mts → ActionPayload.types-CnfWlkA1.d.cts}

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