@nice-code/action 0.7.0 → 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/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,6 +133,7 @@ export declare class ActionServerHandler<TConn = unknown> extends ActionExternal
     private readonly _formatMessage?;
     private readonly _createFormatMessage?;
     private readonly _send;
+    private readonly _runtime?;
     private readonly _serverTimeout;
     private _onConnectionBound?;
     /** Incoming-data listeners installed by the runtime (`resolveIncomingActionPayload`). */
@@ -148,6 +166,18 @@ export declare class ActionServerHandler<TConn = unknown> extends ActionExternal
      * 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;
@@ -183,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/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;

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

@@ -1,6 +1,7 @@
 import { type LucideIcon } from "lucide-react";
 import type { IDevtoolsActionEntry, TDevtoolsActionStatus } from "../../core/ActionDevtools.types";
 import { ESemanticThing } from "../../core/devtools_colors";
+export { formatRelativeAge, formatTimestamp, safeStringify } from "nice-devtools-shared";
 export declare const STATUS_COLOR: Record<TDevtoolsActionStatus, string>;
 export declare const STATUS_THING: Record<TDevtoolsActionStatus, ESemanticThing>;
 export declare const STATUS_SYMBOL: Record<TDevtoolsActionStatus, string>;
@@ -16,7 +17,4 @@ export declare function getInboundOrigin(entry: IDevtoolsActionEntry): {
     perId?: string;
     insId?: string;
 } | null;
-export declare function safeStringify(value: unknown, indent?: number): string;
-export declare function formatRelativeAge(ms: number): string;
 export declare function formatDuration(entry: IDevtoolsActionEntry): string | null;
-export declare function formatTimestamp(startTime: number): string;

package/build/types/devtools/core/ActionDevtools.types.d.ts

@@ -1,7 +1,7 @@
 import type { TActionProgress } from "../../ActionDefinition/Action/Payload/ActionPayload.types";
 import type { IRuntimeCoordinate } from "../../ActionRuntime/RuntimeCoordinate";
+export type { TDevtoolsPosition } from "nice-devtools-shared";
 export type TDevtoolsActionStatus = "running" | "success" | "action-error" | "failed" | "aborted";
-export type TDevtoolsPosition = "dock-bottom" | "dock-top" | "dock-left" | "dock-right";
 export interface IDevtoolsRouteItem {
     runtime: IRuntimeCoordinate;
     handlerType: "local" | "external";

package/build/types/devtools/core/ActionDevtoolsCore.d.ts

@@ -1,10 +1,13 @@
 import type { IDevtoolsActionEntry, IDevtoolsObservableDomain, TDevtoolsListener } from "./ActionDevtools.types";
 export interface IActionDevtoolsCoreOptions {
+    /** Max root entries to retain. Older entries (and their children) are evicted. */
+    maxEntries?: number;
 }
 export declare class ActionDevtoolsCore {
     private _entries;
     private _listeners;
-    constructor(_options?: IActionDevtoolsCoreOptions);
+    private readonly _maxEntries;
+    constructor(options?: IActionDevtoolsCoreOptions);
     attachToDomain(domain: IDevtoolsObservableDomain): () => void;
     getEntries(): readonly IDevtoolsActionEntry[];
     subscribe(listener: TDevtoolsListener): () => void;

package/build/types/devtools/core/devtools_colors.d.ts

@@ -1,39 +1,14 @@
 import type { IChipColorEntry } from "../browser/components/Chip";
-export declare const DEVTOOL_COLOR_SEMANTIC_ERROR = "#FF5C5C";
-export declare const DEVTOOL_COLOR_SEMANTIC_SUCCESS = "#A3E635";
-export declare const DEVTOOL_COLOR_SEMANTIC_SYSTEM = "#38BDF8";
-export declare const DEVTOOL_COLOR_SEMANTIC_WARNING = "#FB923C";
-export declare const DEVTOOL_COLOR_SEMANTIC_METADATA = "#A1A1AA";
+export { DEVTOOL_COLOR_SEMANTIC_ERROR, DEVTOOL_COLOR_SEMANTIC_METADATA, DEVTOOL_COLOR_SEMANTIC_SUCCESS, DEVTOOL_COLOR_SEMANTIC_SYSTEM, DEVTOOL_COLOR_SEMANTIC_WARNING, DEVTOOL_COLOR_TEXT_EMPHASIS, DEVTOOL_COLOR_TEXT_FAINT, DEVTOOL_COLOR_TEXT_MUTED, DEVTOOL_COLOR_TEXT_SECONDARY, DEVTOOL_DETAIL_BASE_BACKGROUND, DEVTOOL_DETAIL_HEADER_BACKGROUND, DEVTOOL_ERROR_BACKGROUND, DEVTOOL_JSON_KEY, DEVTOOL_JSON_KEYWORD, DEVTOOL_JSON_NUMBER, DEVTOOL_JSON_PUNCTUATION, DEVTOOL_JSON_STRING, DEVTOOL_LIST_BASE_BACKGROUND, DEVTOOL_LIST_SELECTED_BACKGROUND, DEVTOOL_PANEL_BORDER, DEVTOOL_PANEL_DIVIDER_BORDER, DEVTOOL_SECTION_BACKGROUND, DEVTOOL_SECTION_STRING_BACKGROUND, DEVTOOL_TOOLTIP_BACKGROUND, DEVTOOL_TOOLTIP_BORDER, DEVTOOL_TOOLTIP_TITLE_BACKGROUND, DEVTOOL_TOOLTIP_TITLE_BOTTOM_BORDER, MONO_FONT, SANS_FONT, } from "nice-devtools-shared";
 export declare const DEVTOOL_COLOR_HANDLER_LOCAL_TEXT = "#34bb89";
 export declare const DEVTOOL_COLOR_HANDLER_LOCAL_BORDER = "#144427";
 export declare const DEVTOOL_COLOR_HANDLER_EXTERNAL_TEXT = "#cfa12a";
 export declare const DEVTOOL_COLOR_HANDLER_EXTERNAL_BORDER = "#723917";
-export declare const DEVTOOL_COLOR_TEXT_EMPHASIS = "#f1f5f9";
-export declare const DEVTOOL_COLOR_TEXT_SECONDARY = "#cbd5e1";
-export declare const DEVTOOL_COLOR_TEXT_MUTED = "#64748b";
-export declare const DEVTOOL_COLOR_TEXT_FAINT = "#334155";
-export declare const DEVTOOL_LIST_BASE_BACKGROUND = "#0f172a";
 export declare const DEVTOOL_LIST_HEADER_SELECTED_BACKGROUND = "#1d2942";
 export declare const DEVTOOL_LIST_GROUP_DIVIDER = "#101109";
-export declare const DEVTOOL_DETAIL_BASE_BACKGROUND = "#0d1729";
-export declare const DEVTOOL_DETAIL_HEADER_BACKGROUND = "#131f35";
-export declare const DEVTOOL_SECTION_BACKGROUND = "#1e293b";
-export declare const DEVTOOL_SECTION_STRING_BACKGROUND = "#0d131f";
 export declare const DEVTOOL_STACK_TRACE_BACKGROUND = "#040a13";
-export declare const DEVTOOL_PANEL_BORDER = "#1e293b";
-export declare const DEVTOOL_PANEL_DIVIDER_BORDER = "#1d3352";
-export declare const DEVTOOL_ERROR_BACKGROUND = "#1e0a0a";
 export declare const DEVTOOL_ERROR_BADGE_BACKGROUND = "#2d0f0f";
-export declare const DEVTOOL_TOOLTIP_BACKGROUND = "#0c1526";
-export declare const DEVTOOL_TOOLTIP_TITLE_BACKGROUND = "#101b2e";
-export declare const DEVTOOL_TOOLTIP_TITLE_BOTTOM_BORDER = "#211f5f";
-export declare const DEVTOOL_TOOLTIP_BORDER = "#312e81";
 export declare const DEVTOOL_COLOR_CALL_STACK_DIVIDER = "#0a1120";
-export declare const DEVTOOL_JSON_KEY = "#a5b4fc";
-export declare const DEVTOOL_JSON_STRING = "#fbbf24";
-export declare const DEVTOOL_JSON_NUMBER = "#34d399";
-export declare const DEVTOOL_JSON_KEYWORD = "#a78bfa";
-export declare const DEVTOOL_JSON_PUNCTUATION = "#475569";
 export declare const DEVTOOL_STACK_FRAME_USER_NUMBER = "#64748b";
 export declare const DEVTOOL_STACK_FRAME_USER_FUNCTION = "#e2e8f0";
 export declare const DEVTOOL_STACK_FRAME_USER_FOLDER = "#596b83";

package/build/types/index.d.ts

@@ -30,8 +30,10 @@ export { createSecureWebSocketTransport, defineSecureWsChannel, type ISecureWebS
 export type { IActionTransportDef_Ws, IActionTransportInitialized_Ws, IActionTransportReadyData_Ws, } from "./ActionRuntime/Handler/ExternalClient/Transport/WebSocket/TransportWebSocket.types";
 export { type IWebSocketTransportAdvancedOptions, type IWebSocketTransportSocketOptions, type TWebSocketTransportOptions, WebSocketTransport, } from "./ActionRuntime/Handler/ExternalClient/Transport/WebSocket/WebSocketTransport";
 export { ActionLocalHandler, createLocalHandler, } from "./ActionRuntime/Handler/Local/ActionLocalHandler";
-export { ActionServerHandler, createServerHandler, type IActionServerConnectionBinding, type IActionServerHandlerOptions, type TActionChannelFormatMessage, type TActionConnectionEncoding, } from "./ActionRuntime/Handler/Server/ActionServerHandler";
+export { ActionServerHandler, createServerHandler, type IActionServerConnectionBinding, type IActionServerHandlerOptions, type TActionChannelFormatMessage, type TActionConnectionEncoding, type TServerConnectionCaseFn, } from "./ActionRuntime/Handler/Server/ActionServerHandler";
+export { createActionFetchHandler, type IActionFetchHandlerOptions, } from "./ActionRuntime/Handler/Server/createActionFetchHandler";
 export { createHibernatableWsServerAdapter, createSecureActionServerHandler, type IHibernatableWsServerAdapter, type IHibernatableWsServerAdapterOptions, type ISecureActionServerHandlerOptions, } from "./ActionRuntime/Handler/Server/createSecureActionServer";
+export { type IConnectionAttachment, type IWsConnectionStateStoreOptions, WsConnectionStateStore, } from "./ActionRuntime/Handler/Server/WsConnectionStateStore";
 export * from "./ActionRuntime/RuntimeCoordinate";
 export { EErrId_NiceAction, err_nice_action } from "./errors/err_nice_action";
 export { decodeActionFrame, type IActionFrameDecoder } from "./utils/decodeActionFrame";