@nice-code/action 0.6.3 → 0.8.0

package/build/types/ActionRuntime/ActionRuntime.d.ts

@@ -1,10 +1,13 @@
+import type { ActionCore } from "../ActionDefinition/Action/Core/ActionCore";
 import type { TActionPayload_Any_Instance } from "../ActionDefinition/Action/Payload/ActionPayload.types";
 import { type TActionPayload_Any_JsonObject } from "../ActionDefinition/Action/Payload/ActionPayload.types";
 import { RunningAction } from "../ActionDefinition/Action/RunningAction";
+import type { ActionDomain } from "../ActionDefinition/Domain/ActionDomain";
 import type { IActionDomain } from "../ActionDefinition/Domain/ActionDomain.types";
 import type { IRuntimeMeta, TActionRuntimeHandler } from "./ActionRuntime.types";
 import { type IHandleActionOptions, type TActionHandler } from "./Handler/ActionHandler.types";
-import type { ActionExternalClientHandler } from "./Handler/ExternalClient/ActionExternalClientHandler";
+import { ActionExternalClientHandler } from "./Handler/ExternalClient/ActionExternalClientHandler";
+import type { Transport } from "./Handler/ExternalClient/Transport/Transport";
 import { type IRuntimeCoordinateSpecifics, RuntimeCoordinate } from "./RuntimeCoordinate";
 export declare class ActionRuntime {
     private _coordinate;
@@ -38,6 +41,25 @@ export declare class ActionRuntime {
      * Duplicate registrations (same handler cuid for the same key) are skipped.
      */
     addHandlers(handlers: TActionRuntimeHandler[]): this;
+    /**
+     * Declare an external "backend client" in one call: build an
+     * {@link ActionExternalClientHandler} for `externalCoordinate` carrying the given
+     * `transports`, route the listed `domains`/`actions` to it, register it (plus any
+     * `localHandlers` — e.g. server→client push handlers that share the same channel)
+     * on this runtime, and `apply()`. Returns the external handler so the caller can
+     * later `clearTransportCache()` it.
+     *
+     * Sugar over `new ActionExternalClientHandler(...).forDomain(...)` + `addHandlers([...])`,
+     * so a single runtime can host one handler per backend target with its transports
+     * declared once and reused across every action routed to that backend.
+     */
+    connectTo(externalCoordinate: RuntimeCoordinate, options: {
+        transports: Transport[];
+        domains?: ActionDomain<any>[];
+        actions?: ActionCore<any, any>[];
+        localHandlers?: TActionRuntimeHandler[];
+        defaultTimeout?: number;
+    }): ActionExternalClientHandler;
     private applyRuntimeForDomain;
     /**
      * Register this runtime with all root domains covered by its currently-added handlers,

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/Transport.types.d.ts

@@ -99,6 +99,12 @@ export interface IActionTransportReadyData_Methods extends IActionTransportReady
      */
     sendReturnData?: TSendReturnDataMethod;
     addOnDisconnectListener?: (callback: () => void) => void;
+    /**
+     * Optional — implement on transports holding a long-lived connection (WebSocket, Custom) to close it
+     * deliberately. Called by `ActionExternalClientHandler.clearTransportCache()` so a teardown actually
+     * releases the underlying socket instead of leaving it open until GC.
+     */
+    disconnect?: () => void;
 }
 export interface IActionTransportReady {
     methods: IActionTransportReadyData_Methods;

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketConnection.d.ts

@@ -3,9 +3,10 @@ import { TransportConnection } from "../TransportConnection";
 import type { IActionTransportDef_Ws, IActionTransportInitialized_Ws, IActionTransportReadyData_Ws } from "./TransportWebSocket.types";
 export declare class WebSocketConnection extends TransportConnection<ETransportType.ws, ITransportRouteActionParams, IActionTransportReadyData_Ws, IActionTransportInitialized_Ws, IActionTransportDef_Ws> {
     private resolvers;
-    private _abortSet;
     /** URL of the most recently resolved live socket — surfaced to devtools when the definition can't. */
     private _liveSocketUrl?;
+    /** Sockets we closed on purpose (via `disconnect`), so their `close` event stays quiet. */
+    private _intentionalCloses;
     constructor(def: Omit<IActionTransportDef_Ws, "type">, resolvers?: IActionTransportResolvers);
     protected _getCacheKey(_input: ITransportRouteActionParams): string;
     protected _processTransportStatus(input: ITransportRouteActionParams): TTransportStatusInfo<IActionTransportReadyData_Methods>;

package/build/types/ActionRuntime/Handler/ExternalClient/Transport/WebSocket/secureWsChannel.d.ts

@@ -0,0 +1,63 @@
+import { type StorageAdapter } from "@nice-code/util";
+import type { ActionDomain } from "../../../../../ActionDefinition/Domain/ActionDomain";
+import type { ActionRuntime } from "../../../../ActionRuntime";
+import type { ITransportRouteActionParams, ITransportRouteInfo, TUpdateActionRunConfig } from "../Transport.types";
+import { ESecurityLevel } from "./actionWsHandshake";
+import { type IBinaryWsSessionOptions } from "./createBinaryWsSessionFactory";
+import type { IActionTransportReadyData_Ws } from "./TransportWebSocket.types";
+import { WebSocketTransport } from "./WebSocketTransport";
+/** The per-connection binary session codec — built once per socket from the channel's domains. */
+type TChannelCodec = NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;
+/**
+ * The shared identity of a secure WebSocket channel: the wire dictionary version both ends check
+ * during the handshake, plus the per-connection codec factory both ends build from the *same* domain
+ * list. Define it once (typically in code shared by client and server) and hand it to
+ * {@link createSecureWebSocketTransport} on the client and `createSecureActionServerHandler` on the
+ * server, so the codec and version can never drift apart.
+ */
+export interface ISecureWsChannel {
+    /** Wire dictionary version — derived from the domains by default; the handshake rejects a mismatch. */
+    dictionaryVersion: string;
+    /** Per-connection session codec factory (call once per live connection). */
+    createCodec: () => TChannelCodec;
+}
+/**
+ * Bundle a secure channel's shared identity from its transported domains. Both ends MUST call this
+ * with the same domains in the same order (the binary wire dictionary is positional). The
+ * `dictionaryVersion` is derived from those domains unless you pin an explicit one.
+ */
+export declare function defineSecureWsChannel(options: {
+    /** Domains transported over this channel, in a stable order. Add new ones to the *end*. */
+    domains: ActionDomain<any>[];
+    /** Pin a human-readable version instead of the derived hash (must match on both ends). */
+    dictionaryVersion?: string;
+    /** Tuning for the per-connection binary session (e.g. correlation TTL). */
+    sessionOptions?: IBinaryWsSessionOptions;
+}): ISecureWsChannel;
+export interface ISecureWebSocketTransportOptions {
+    /** The shared channel identity (codec + dictionary version). */
+    channel: ISecureWsChannel;
+    /** This client's runtime — its coordinate is the authenticated identity sent in the handshake. */
+    runtime: ActionRuntime;
+    /** Backing store for this client's crypto identity (a stable verify key across reloads). */
+    storageAdapter: StorageAdapter;
+    /** The level this client requests; the server must allow it. */
+    securityLevel: ESecurityLevel;
+    /** Endpoint URL — drives both the socket and the per-endpoint cache key. */
+    url: string;
+    /** Override socket creation (defaults to a `new WebSocket(url)` with `binaryType = "arraybuffer"`). */
+    createWebSocket?: (input: ITransportRouteActionParams) => WebSocket;
+    /** Override the reuse key (defaults to `[url]`, so one socket is shared per endpoint). */
+    getTransportCacheKey?: (input: ITransportRouteActionParams) => string[];
+    updateRunConfig?: TUpdateActionRunConfig;
+    getRouteInfo?: (input: ITransportRouteActionParams) => ITransportRouteInfo;
+}
+/**
+ * Build a {@link WebSocketTransport} for the secure binary channel with the boilerplate folded in: it
+ * creates the {@link ClientCryptoKeyLink} from `storageAdapter`, opens an `arraybuffer` socket to
+ * `url`, caches it per endpoint, installs the channel's per-connection codec, and assembles the
+ * `security` block from the runtime coordinate + channel version. Pass `createWebSocket` /
+ * `getTransportCacheKey` to take over those bits when you need to.
+ */
+export declare function createSecureWebSocketTransport(options: ISecureWebSocketTransportOptions): WebSocketTransport;
+export {};

package/build/types/ActionRuntime/Handler/Server/ActionServerHandler.d.ts

@@ -1,8 +1,10 @@
 import type { ClientCryptoKeyLink, TTypeAndId } from "@nice-code/util";
+import type { TDistributeActionPayload_Request } from "../../../ActionDefinition/Action/Action.combined.types";
 import type { IActionRouteItemHandler } from "../../../ActionDefinition/Action/Payload/ActionPayload.types";
 import { type TActionPayload_Any_Instance, type TActionPayload_Any_JsonObject } from "../../../ActionDefinition/Action/Payload/ActionPayload.types";
 import type { ActionPayload_Request } from "../../../ActionDefinition/Action/Payload/ActionPayload_Request";
 import { RunningAction } from "../../../ActionDefinition/Action/RunningAction";
+import type { ActionDomain } from "../../../ActionDefinition/Domain/ActionDomain";
 import type { IActionDomain } from "../../../ActionDefinition/Domain/ActionDomain.types";
 import { ActionRuntime } from "../../ActionRuntime";
 import { type IRuntimeCoordinate, RuntimeCoordinate } from "../../RuntimeCoordinate";
@@ -10,6 +12,9 @@ import type { IHandleActionOptions } from "../ActionHandler.types";
 import { ActionExternalClientHandler } from "../ExternalClient/ActionExternalClientHandler";
 import { ESecurityLevel, type IClientVerifyKeyResolver, type IHandshakeEncryptionKeyMaterial } from "../ExternalClient/Transport/WebSocket/actionWsHandshake";
 import type { IActionTransportReadyData_Ws } from "../ExternalClient/Transport/WebSocket/TransportWebSocket.types";
+import { ActionLocalHandler } from "../Local/ActionLocalHandler";
+import type { THandleActionExecutionFn } from "../Local/ActionLocalHandler.types";
+import { type IWsConnectionStateStoreOptions, WsConnectionStateStore } from "./WsConnectionStateStore";
 /** The codec shape `ActionServerHandler` uses to pack/unpack frames — same as the WS transport's. */
 export type TActionChannelFormatMessage = NonNullable<IActionTransportReadyData_Ws["formatMessage"]>;
 /** How a connection encodes its frames, remembered so we answer each client in its own dialect. */
@@ -62,6 +67,11 @@ interface IActionServerHandlerBaseOptions<TConn> {
     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;
+    /**
+     * The runtime this handler belongs to. When set, {@link ActionServerHandler.broadcast} can be called
+     * without threading a runtime through each call. Optional — `pushToClient` still takes one explicitly.
+     */
+    runtime?: ActionRuntime;
     /** Timeout (ms) applied to server-initiated actions awaiting a client response. */
     defaultTimeout?: number;
     /**
@@ -91,6 +101,13 @@ export type IActionServerHandlerOptions<TConn> = IActionServerHandlerBaseOptions
     createFormatMessage: () => TActionChannelFormatMessage;
     formatMessage?: never;
 });
+/**
+ * A connection-aware execution case (see {@link ActionServerHandler.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.
+ */
+export type TServerConnectionCaseFn<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string, TConn> = (action: TDistributeActionPayload_Request<DOM, ID>, connection: TConn | undefined) => ReturnType<THandleActionExecutionFn<DOM, ID>> | void;
 /**
  * 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
@@ -116,8 +133,9 @@ export declare class ActionServerHandler<TConn = unknown> extends ActionExternal
     private readonly _formatMessage?;
     private readonly _createFormatMessage?;
     private readonly _send;
+    private readonly _runtime?;
     private readonly _serverTimeout;
-    private readonly _onConnectionBound?;
+    private _onConnectionBound?;
     /** Incoming-data listeners installed by the runtime (`resolveIncomingActionPayload`). */
     private readonly _incomingListeners;
     private readonly _security?;
@@ -142,6 +160,24 @@ export declare class ActionServerHandler<TConn = unknown> extends ActionExternal
      */
     private _codecFor;
     _setIncomingActionDataListener(listener: (json: TActionPayload_Any_JsonObject<any>) => void): void;
+    /**
+     * Register (or replace) the connection-bound persistence callback after construction. Used by
+     * lifecycle helpers like {@link createHibernatableWsServerAdapter} so persistence and replay are
+     * owned by one place instead of being split across the constructor options.
+     */
+    setOnConnectionBound(onConnectionBound: (connection: TConn, binding: IActionServerConnectionBinding) => void): void;
+    /**
+     * Create a typed per-connection state store that co-owns the consumer's app state and this handler's
+     * routing binding in one attachment. It registers itself as the connection-bound persistence callback
+     * (so bindings are written without overwriting app state) and immediately replays every live
+     * connection's stored binding via {@link 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.
+     *
+     * This supersedes {@link createHibernatableWsServerAdapter} for app code that also pins its own state
+     * to the connection. Construct it once when the handler is built, then `get`/`set` app state directly.
+     */
+    createConnectionState<TApp>(options: IWsConnectionStateStoreOptions<TConn, TApp>): WsConnectionStateStore<TConn, TApp>;
     /**
      * Feed one inbound frame from a connection into the runtime. Decodes text or binary, binds the
      * connection to the requesting client's identity, then routes it (requests execute locally;
@@ -177,6 +213,33 @@ export declare class ActionServerHandler<TConn = unknown> extends ActionExternal
     pushToClient<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(runtime: ActionRuntime, target: TConn | RuntimeCoordinate, request: ActionPayload_Request<DOM, ID>, options?: {
         timeout?: number;
     }): RunningAction<DOM, ID>;
+    /**
+     * Build a local handler whose cases are connection-aware: each case receives the primed request and
+     * the originating client's live connection (resolved from `originClient`), so handlers don't repeat
+     * the `getConnectionForClient(action.context.originClient)` lookup. Cases may return raw output or
+     * nothing, just like {@link ActionLocalHandler.forDomainActionCases}. Add the returned handler to the
+     * runtime alongside this server handler:
+     * ```ts
+     * runtime.addHandlers([serverHandler.forConnectionDomainCases(domain, { … }), serverHandler]);
+     * ```
+     */
+    forConnectionDomainCases<FOR_DOM extends IActionDomain>(domain: ActionDomain<FOR_DOM>, cases: {
+        [ID in keyof FOR_DOM["actionSchema"] & string]?: TServerConnectionCaseFn<FOR_DOM, ID, TConn>;
+    }): 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
+     * `except` to skip the originating socket and `where` to filter by connection (e.g. read its
+     * attachment for a role). Iterating bound connections (rather than every accepted socket) skips
+     * sockets that are still mid-handshake and so can't yet receive a frame.
+     */
+    broadcast<DOM extends IActionDomain, ID extends keyof DOM["actionSchema"] & string>(makeRequest: () => ActionPayload_Request<DOM, ID>, options?: {
+        runtime?: ActionRuntime;
+        except?: TConn | null;
+        where?: (connection: TConn) => boolean;
+        timeout?: number;
+        onError?: (error: unknown, connection: TConn) => void;
+    }): void;
     sendReturnPayload(payload: TActionPayload_Any_Instance<any, any>, config: {
         targetLocalRuntime: ActionRuntime;
     }): Promise<boolean>;

package/build/types/ActionRuntime/Handler/Server/WsConnectionStateStore.d.ts

@@ -0,0 +1,61 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { IActionServerConnectionBinding } from "./ActionServerHandler";
+/**
+ * The composite value persisted to a connection's attachment: the consumer's own app state plus the
+ * {@link ActionServerHandler} 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.
+ */
+export interface IConnectionAttachment<TApp> {
+    app?: TApp;
+    binding?: IActionServerConnectionBinding;
+}
+export interface IWsConnectionStateStoreOptions<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 ActionServerHandler.createConnectionState}) and to enumerate app state in
+     * {@link WsConnectionStateStore.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 server handler's routing
+ * binding in one attachment, so neither the consumer nor the handler has to hand-merge the two. Create
+ * it through {@link ActionServerHandler.createConnectionState} (which also wires binding persistence and
+ * replays surviving connections after a wake), then `get`/`set`/`clearApp` the app state directly.
+ *
+ * ```ts
+ * const players = serverHandler.createConnectionState({
+ *   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);
+ * ```
+ */
+export declare class WsConnectionStateStore<TConn, TApp> {
+    private readonly options;
+    constructor(options: IWsConnectionStateStoreOptions<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][];
+    private _readAttachment;
+    private _validateApp;
+}

package/build/types/ActionRuntime/Handler/Server/createActionFetchHandler.d.ts

@@ -0,0 +1,40 @@
+import type { ActionRuntime } from "../../ActionRuntime";
+export interface IActionFetchHandlerOptions {
+    /**
+     * CORS headers merged onto every response (a preflight `OPTIONS` is answered `204` with them).
+     * Defaults to permissive `*`; pass `false` to attach no CORS headers at all.
+     */
+    cors?: Record<string, string> | false;
+    /** Which requests carry an action wire on `POST`. Default: pathname ends with `/action`. */
+    isActionPath?: (url: URL) => boolean;
+    /** Which requests are WebSocket upgrades. Default: pathname ends with `/ws`. */
+    isWebSocketPath?: (url: URL) => boolean;
+    /**
+     * Perform the transport-specific WebSocket upgrade (e.g. a Durable Object's
+     * `new WebSocketPair()` + `ctx.acceptWebSocket()` returning a `101`). Omit for HTTP-only endpoints.
+     * Its response is returned as-is — a `101` upgrade carries no CORS headers.
+     */
+    onWebSocketUpgrade?: (request: Request, url: URL) => Response | Promise<Response>;
+    /** Forwarded to `ActionPayload_Result.toHttpResponse` — use the error's HTTP status (default true). */
+    useErrorStatus?: boolean;
+}
+/**
+ * Build the `fetch` handler a server/Durable-Object exposes for action traffic, folding in the
+ * boilerplate every endpoint repeats: CORS (incl. the `OPTIONS` preflight), routing the `/action`
+ * `POST` body through the runtime (`handleActionPayloadWire` → `waitForResultPayload` →
+ * `toHttpResponse`), an optional WebSocket-upgrade hook, and a `404` fallback.
+ *
+ * It only touches web-standard `Request`/`Response`, so it stays transport-agnostic — the one
+ * environment-specific bit (the WS upgrade) is injected via {@link IActionFetchHandlerOptions.onWebSocketUpgrade}:
+ * ```ts
+ * this.fetchHandler = createActionFetchHandler(this.runtime, {
+ *   onWebSocketUpgrade: () => {
+ *     const pair = new WebSocketPair();
+ *     this.ctx.acceptWebSocket(pair[1]);
+ *     return new Response(null, { status: 101, webSocket: pair[0] });
+ *   },
+ * });
+ * // async fetch(request) { return this.fetchHandler(request); }
+ * ```
+ */
+export declare function createActionFetchHandler(runtime: ActionRuntime, options?: IActionFetchHandlerOptions): (request: Request) => Promise<Response>;

package/build/types/ActionRuntime/Handler/Server/createSecureActionServer.d.ts

@@ -0,0 +1,71 @@
+import { type StorageAdapter } from "@nice-code/util";
+import type { ActionRuntime } from "../../ActionRuntime";
+import type { RuntimeCoordinate } from "../../RuntimeCoordinate";
+import { ESecurityLevel, type IClientVerifyKeyResolver } from "../ExternalClient/Transport/WebSocket/actionWsHandshake";
+import type { ISecureWsChannel } from "../ExternalClient/Transport/WebSocket/secureWsChannel";
+import { ActionServerHandler, type IActionServerConnectionBinding } from "./ActionServerHandler";
+export interface ISecureActionServerHandlerOptions<TConn> {
+    /** The shared channel identity (codec + dictionary version) — same one the clients use. */
+    channel: ISecureWsChannel;
+    /**
+     * Coordinate of the *connecting clients* (typically env-only, e.g. `RuntimeCoordinate.env("web_app")`),
+     * used to route results/pushes back over this handler.
+     */
+    clientEnv: RuntimeCoordinate;
+    /** This server's runtime — its coordinate is the server identity presented in the handshake. */
+    runtime: ActionRuntime;
+    /**
+     * One backing store for the server's crypto identity *and* its trust-on-first-use verify-key pins.
+     * Their keys don't collide, so a single adapter is enough; back it with persistent storage (e.g. a
+     * Durable Object's storage) so identity and pins survive eviction.
+     */
+    storageAdapter: StorageAdapter;
+    /** Write an encoded frame to a specific live connection (e.g. `(ws, frame) => ws.send(frame)`). */
+    send: (connection: TConn, frame: string | Uint8Array | ArrayBuffer) => void;
+    /** Accepted level(s); defaults to negotiating any of none/authenticated/encrypted. */
+    securityLevel?: ESecurityLevel | readonly ESecurityLevel[];
+    /** Trust decision for a client's verify key; defaults to storage-backed TOFU over `storageAdapter`. */
+    verifyKeyResolver?: IClientVerifyKeyResolver;
+    /** Timeout (ms) applied to server-initiated actions awaiting a client response. */
+    defaultTimeout?: number;
+}
+/**
+ * Build an {@link ActionServerHandler} for the secure binary channel with the boilerplate folded in:
+ * it creates the {@link ClientCryptoKeyLink} and the storage-backed TOFU resolver from a single
+ * `storageAdapter`, installs the channel's per-connection codec, and assembles the `security` block
+ * from the runtime coordinate + channel version (accepting all three levels by default).
+ *
+ * For a hibernatable transport (e.g. a Durable Object), pair it with
+ * {@link createHibernatableWsServerAdapter} to wire persistence + replay.
+ */
+export declare function createSecureActionServerHandler<TConn = unknown>(options: ISecureActionServerHandlerOptions<TConn>): ActionServerHandler<TConn>;
+export interface IHibernatableWsServerAdapterOptions<TConn> {
+    /** The handler to drive (from {@link createSecureActionServerHandler} or `createServerHandler`). */
+    handler: ActionServerHandler<TConn>;
+    /** All currently-live connections — replayed on construction to rebuild bindings after a wake. */
+    getWebSockets: () => TConn[];
+    /** Read a connection's persisted binding (e.g. `(ws) => ws.deserializeAttachment()`). */
+    getAttachment: (connection: TConn) => IActionServerConnectionBinding | undefined;
+    /** Persist a connection's binding when it is bound (e.g. `(ws, b) => ws.serializeAttachment(b)`). */
+    setAttachment: (connection: TConn, binding: IActionServerConnectionBinding) => void;
+}
+export interface IHibernatableWsServerAdapter<TConn> {
+    /** Feed one inbound frame from a connection into the handler. */
+    receive: (connection: TConn, frame: string | ArrayBuffer | Uint8Array) => void;
+    /** Forget a connection (call on socket close/error). */
+    drop: (connection: TConn) => void;
+}
+/**
+ * Wire the hibernation lifecycle for a server handler on a transport whose sockets outlive process
+ * eviction (e.g. a Durable Object's hibernatable WebSockets). It owns persistence end to end:
+ * registers `setAttachment` as the handler's connection-bound callback and immediately replays every
+ * live connection's stored binding via `getAttachment`, so results/pushes still route after a wake.
+ *
+ * Construct it once when the handler is built, then forward socket events:
+ * ```ts
+ * const wsServer = createHibernatableWsServerAdapter({ handler, getWebSockets, getAttachment, setAttachment });
+ * // webSocketMessage(ws, msg) => wsServer.receive(ws, msg);
+ * // webSocketClose/Error(ws)  => wsServer.drop(ws);
+ * ```
+ */
+export declare function createHibernatableWsServerAdapter<TConn>(options: IHibernatableWsServerAdapterOptions<TConn>): IHibernatableWsServerAdapter<TConn>;

package/build/types/devtools/browser/NiceActionDevtools.d.ts

@@ -11,4 +11,4 @@ export interface IEntryGroup {
     representative: IDevtoolsActionEntry;
     rest: IDevtoolsActionEntry[];
 }
-export declare function NiceActionDevtools({ forceEnable, ...props }: INiceActionDevtoolsProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function NiceActionDevtools({ forceEnable, ...props }: INiceActionDevtoolsProps): import("react").JSX.Element | null;

package/build/types/devtools/browser/components/ActionErrorDisplay.d.ts

@@ -2,4 +2,4 @@ import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
 export declare function ActionErrorDisplay({ entry, compact, }: {
     entry: IDevtoolsActionEntry;
     compact?: boolean;
-}): import("react/jsx-runtime").JSX.Element | null;
+}): import("react").JSX.Element | null;

package/build/types/devtools/browser/components/CallStackSection.d.ts

@@ -5,4 +5,4 @@ export declare function CallStackSection({ parent, childEntries, focusedChildCui
     focusedChildCuid: string | null;
     onFocusChild: (cuid: string) => void;
     onSelectParent: (cuid: string) => void;
-}): import("react/jsx-runtime").JSX.Element | null;
+}): import("react").JSX.Element | null;

package/build/types/devtools/browser/components/ChildDispatchChips.d.ts

@@ -3,4 +3,4 @@ import { ESize } from "../ui_util/size";
 export declare function ChildDispatchChips({ childRouteItems, size, }: {
     childRouteItems?: IDevtoolsRouteItem[];
     size?: ESize;
-}): import("react/jsx-runtime").JSX.Element | null;
+}): import("react").JSX.Element | null;

package/build/types/devtools/browser/components/Chip.d.ts

@@ -18,5 +18,5 @@ interface IChipProps {
     tooltip?: ITooltipConfig;
     children: ReactNode;
 }
-export declare function Chip({ color, subtle, size, rounded, tooltip, children, }: IChipProps): import("react/jsx-runtime").JSX.Element;
+export declare function Chip({ color, subtle, size, rounded, tooltip, children, }: IChipProps): import("react").JSX.Element;
 export {};

package/build/types/devtools/browser/components/DetailSection.d.ts

@@ -2,4 +2,4 @@ export declare function DetailSection({ label, value, color, }: {
     label: string;
     value: unknown;
     color?: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/DomainChip.d.ts

@@ -5,4 +5,4 @@ export declare function DomainChip({ compact, subtle, domain, allDomains, size,
     domain: string;
     allDomains: string[];
     size?: ESize;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/HandlerChips.d.ts

@@ -17,5 +17,5 @@ interface IHandlerChipsProps {
     size: ESize;
     subtle?: boolean;
 }
-export declare function HandlerChips({ entry, size, subtle }: IHandlerChipsProps): import("react/jsx-runtime").JSX.Element;
+export declare function HandlerChips({ entry, size, subtle }: IHandlerChipsProps): import("react").JSX.Element;
 export {};

package/build/types/devtools/browser/components/Icon.d.ts

@@ -12,5 +12,5 @@ interface IIconProps {
     style?: CSSProperties;
     noBackground?: boolean;
 }
-export declare function Icon({ icon: IconComponent, color, size, subtle, tooltip, style, noBackground, }: IIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function Icon({ icon: IconComponent, color, size, subtle, tooltip, style, noBackground, }: IIconProps): import("react").JSX.Element;
 export {};

package/build/types/devtools/browser/components/MetaSection.d.ts

@@ -1,4 +1,4 @@
 import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
 export declare function MetaSection({ entry }: {
     entry: IDevtoolsActionEntry;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/NiceErrorDisplay.d.ts

@@ -11,9 +11,9 @@ export type TNiceErrorJson = {
 export declare function isNiceErrorJson(value: unknown): value is TNiceErrorJson;
 export declare function NiceErrorBody({ error }: {
     error: TNiceErrorJson;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function NiceErrorDisplay({ error, label, color, }: {
     error: TNiceErrorJson;
     label: string;
     color: string;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/OriginChip.d.ts

@@ -12,4 +12,4 @@ export declare function OriginChip({ origin, size, subtle, }: {
     };
     size?: ESize;
     subtle?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/RoutingSection.d.ts

@@ -2,4 +2,4 @@ import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
 export declare function RoutingSection({ entry, minHopCount, }: {
     entry: IDevtoolsActionEntry;
     minHopCount?: number;
-}): import("react/jsx-runtime").JSX.Element | null;
+}): import("react").JSX.Element | null;

package/build/types/devtools/browser/components/RunningTimer.d.ts

@@ -1,7 +1,7 @@
 import type { IDevtoolsActionEntry } from "../../core/ActionDevtools.types";
 export declare function RunningTimer({ startTime }: {
     startTime: number;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 export declare function DurationDisplay({ entry }: {
     entry: IDevtoolsActionEntry;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/SectionLabel.d.ts

@@ -1,4 +1 @@
-export declare function SectionLabel({ label, color, }: {
-    label: string;
-    color?: string;
-}): import("react/jsx-runtime").JSX.Element;
+export { SectionLabel } from "nice-devtools-shared";

package/build/types/devtools/browser/components/StackTraceSection.d.ts

@@ -6,4 +6,4 @@ export declare function StackTraceSection({ label, stack, color, runtime, minFra
     runtime: IRuntimeCoordinate;
     color?: string;
     minFrameCount?: number;
-}): import("react/jsx-runtime").JSX.Element | null;
+}): import("react").JSX.Element | null;

package/build/types/devtools/browser/components/Tooltip.d.ts

@@ -1,24 +1 @@
-import { type CSSProperties, type ReactNode } from "react";
-export interface ITooltipConfig {
-    content: ReactNode;
-    title?: ReactNode;
-    /** "center" centers the tooltip above/below the anchor (default).
-     *  "edge" aligns the nearer horizontal edge with the anchor edge. */
-    align?: "center" | "edge";
-    maxWidth?: number;
-}
-export declare function Tooltip({ anchor, config, children, }: {
-    anchor: DOMRect;
-    config: ITooltipConfig;
-    children?: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
-/**
- * Wraps inline content so it shows `config` as a hover tooltip. When `config` is null the children
- * render untouched (no hover handlers, no tooltip). Useful for non-Chip text labels that still need
- * the same tooltip treatment as Chips.
- */
-export declare function HoverTooltip({ config, children, style, }: {
-    config?: ITooltipConfig;
-    children: ReactNode;
-    style?: CSSProperties;
-}): import("react/jsx-runtime").JSX.Element;
+export { HoverTooltip, type ITooltipConfig, Tooltip } from "nice-devtools-shared";

package/build/types/devtools/browser/components/action_detail/ActionDetailPanel.d.ts

@@ -4,4 +4,4 @@ export declare function ActionDetailPanel({ entry, parent, childEntries, onSelec
     parent: IDevtoolsActionEntry | null;
     childEntries: IDevtoolsActionEntry[];
     onSelectEntry: (cuid: string) => void;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/action_list/ActionEntryRow.d.ts

@@ -11,4 +11,4 @@ export declare function ActionEntryRow({ entry, isSelected, onClick, isLatest, l
     groupEntries?: IDevtoolsActionEntry[];
     selectedGroupCuid?: string | null;
     onSelectGroupEntry?: (cuid: string) => void;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/action_list/ActionInputAndOutputChip.d.ts

@@ -7,5 +7,5 @@ interface IActionInputAndOutputChipProps {
     subtle?: boolean;
     size?: ESize;
 }
-export declare const ActionInputAndOutputChip: ({ entry, breakReasons, subtle, size, }: IActionInputAndOutputChipProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ActionInputAndOutputChip: ({ entry, breakReasons, subtle, size, }: IActionInputAndOutputChipProps) => import("react").JSX.Element;
 export {};

package/build/types/devtools/browser/components/action_list/ActionList.d.ts

@@ -7,4 +7,4 @@ export declare function ActionList({ groups, selectedCuid, onGroupClick, onSubCl
     onSubClick: (cuid: string, isSelected: boolean) => void;
     childEntriesMap: Map<string, IDevtoolsActionEntry[]>;
     style?: React.CSSProperties;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;

package/build/types/devtools/browser/components/action_list/IoTooltipContent.d.ts

@@ -1,6 +1,3 @@
-export declare const _IoTooltipContent: ({ value }: {
-    value: unknown;
-}) => import("react/jsx-runtime").JSX.Element;
 export declare function IoTooltipContent({ value }: {
     value: unknown;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;