@fuzdev/fuz_app 0.24.0 → 0.25.0

package/dist/actions/socket.svelte.js

@@ -26,6 +26,7 @@
 import { BROWSER } from 'esm-env';
 import { JSONRPC_VERSION } from '../http/jsonrpc.js';
 import { WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT, WS_CLOSE_SESSION_REVOKED } from './transports.js';
+import { CANCEL_METHOD } from './cancel.js';
 import { HEARTBEAT_METHOD } from './heartbeat.js';
 /** Default WebSocket close code (normal closure). */
 export const DEFAULT_CLOSE_CODE = 1000;
@@ -253,19 +254,29 @@ export class FrontendWebsocketClient {
     }
     /**
      * Promise-based JSON-RPC over the socket. Auto-assigns a monotonic request
-     * id, tracks the pending promise, and resolves when the server sends a
-     * matching response (or rejects on error frame, socket close, or aborted
-     * signal).
+     * id (or uses an explicit one supplied via `options.id` — used by
+     * `FrontendWebsocketTransport` which delegates to this method and has its
+     * own peer-minted UUID), tracks the pending promise, and resolves when the
+     * server sends a matching response (or rejects on error frame, socket
+     * close, or aborted signal).
+     *
+     * Callers supplying an explicit `options.id` are responsible for
+     * uniqueness — the pending map is keyed by id, and a duplicate silently
+     * overwrites the prior entry. Auto-minted ids are monotonic and never
+     * collide with themselves or with peer-minted UUIDs (the types differ:
+     * integer vs string).
      *
      * While the socket is disconnected, the request is buffered in a bounded
-     * queue (default-on, {@link DEFAULT_QUEUE_MAX_SIZE}) and flushed on
-     * reopen. Pass `{queue: false}` to reject immediately when disconnected
-     * — used internally by the heartbeat, which must not fight the queue for
-     * the disconnect-detection slot.
+     * queue (default-on, `DEFAULT_QUEUE_MAX_SIZE`) and flushed on reopen. Pass
+     * `{queue: false}` to reject immediately when disconnected — used
+     * internally by the heartbeat, which must not fight the queue for the
+     * disconnect-detection slot.
      *
-     * `AbortSignal` integration today rejects the local promise; the
-     * server-side cancel protocol (sending a `cancel` notification to abort
-     * the in-flight handler) lands in Phase 3c as a follow-up PR.
+     * On `AbortSignal` fire: rejects the local promise *and* sends the shared
+     * `cancel` notification (`CANCEL_METHOD`) so the server-side dispatcher
+     * can abort the matching handler's `ctx.signal`. Suppressed for
+     * queued-but-never-sent (server doesn't know about it) and
+     * response-beat-cancel races.
      */
     request(method, params = {}, options = {}) {
         return new Promise((resolve, reject) => {
@@ -280,7 +291,7 @@ export class FrontendWebsocketClient {
                 reject_typed(this.#build_abort_error(method));
                 return;
             }
-            const id = ++this.#next_request_id;
+            const id = options.id ?? ++this.#next_request_id;
             const frame = { jsonrpc: JSONRPC_VERSION, id, method, params };
             // Bind the signal listener up-front so `#detach_signal` can find it by
             // reference regardless of which settlement path runs (inline send,
@@ -290,11 +301,21 @@ export class FrontendWebsocketClient {
                 ? () => {
                     if (!pending)
                         return;
-                    this.#pending.delete(id);
+                    // `Map.delete` returns true iff the entry existed — which
+                    // is our signal that the frame was actually written to
+                    // the socket (pending-only tracks in-flight). If it was
+                    // only queued (never sent), the server doesn't know
+                    // about it and doesn't need a cancel. If the response
+                    // beat the abort, `#handle_message` already deleted the
+                    // entry and detached this listener, so this closure
+                    // never runs in that race.
+                    const was_in_flight = this.#pending.delete(id);
                     this.#drop_queued(id);
                     this.#detach_signal(pending);
                     pending = null;
                     reject_typed(this.#build_abort_error(method));
+                    if (was_in_flight)
+                        this.#send_cancel(id);
                 }
                 : null;
             if (signal && signal_handler)
@@ -337,6 +358,19 @@ export class FrontendWebsocketClient {
     #build_abort_error(method) {
         return new Error(`[socket] request aborted (method=${method})`);
     }
+    /**
+     * Fire-and-forget cancel notification to the server. The dispatcher
+     * looks up the matching pending handler's per-request `AbortController`
+     * and aborts it; unknown ids no-op. Drops silently when disconnected —
+     * the server's own socket-close path will abort any in-flight handlers.
+     */
+    #send_cancel(request_id) {
+        this.send({
+            jsonrpc: JSONRPC_VERSION,
+            method: CANCEL_METHOD,
+            params: { request_id },
+        });
+    }
     #detach_signal(pending) {
         if (pending.signal && pending.signal_handler) {
             pending.signal.removeEventListener('abort', pending.signal_handler);

package/dist/actions/transports.d.ts

@@ -16,11 +16,22 @@ export declare const WS_CLOSE_CLIENT_HEARTBEAT_TIMEOUT = 4002;
 export declare const WS_CLOSE_SERVER_HEARTBEAT_TIMEOUT = 4003;
 export declare const TransportName: z.ZodString;
 export type TransportName = z.infer<typeof TransportName>;
+/**
+ * Per-call options accepted by every transport's `send`. Optional and
+ * extensible — adding a field is non-breaking. Today: an `AbortSignal`
+ * for cancellation that bottoms out at `FrontendWebsocketClient.request`
+ * (which sends the shared `cancel` notification on abort) and at
+ * `fetch({signal})` for HTTP. Backend transport receives the option but
+ * has no per-call abort surface to honor.
+ */
+export interface TransportSendOptions {
+    signal?: AbortSignal;
+}
 export interface Transport {
     transport_name: TransportName;
-    send(message: JsonrpcRequest): Promise<JsonrpcResponseOrError>;
-    send(message: JsonrpcNotification): Promise<JsonrpcErrorResponse | null>;
-    send(message: JsonrpcMessageFromClientToServer): Promise<JsonrpcMessageFromServerToClient | null>;
+    send(message: JsonrpcRequest, options?: TransportSendOptions): Promise<JsonrpcResponseOrError>;
+    send(message: JsonrpcNotification, options?: TransportSendOptions): Promise<JsonrpcErrorResponse | null>;
+    send(message: JsonrpcMessageFromClientToServer, options?: TransportSendOptions): Promise<JsonrpcMessageFromServerToClient | null>;
     is_ready: () => boolean;
     dispose?: () => void;
 }

package/dist/actions/transports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transports.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,KAAK,EACX,gCAAgC,EAChC,gCAAgC,EAChC,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAE5B,mDAAmD;AACnD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,sEAAsE;AACtE,eAAO,MAAM,iCAAiC,OAAO,CAAC;AACtD,yEAAyE;AACzE,eAAO,MAAM,iCAAiC,OAAO,CAAC;AAKtD,eAAO,MAAM,aAAa,aAAa,CAAC;AACxC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,MAAM,WAAW,SAAS;IACzB,cAAc,EAAE,aAAa,CAAC;IAE9B,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IACzE,IAAI,CAAC,OAAO,EAAE,gCAAgC,GAAG,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC,CAAC;IAClG,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,qBAAa,UAAU;;IAItB;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAQ;IAE/B;;OAEG;IACH,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAS9C,qBAAqB,CAAC,cAAc,EAAE,aAAa,GAAG,IAAI;IAM1D;;;;;OAKG;IACH,aAAa,CAAC,cAAc,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI;IAO/D,QAAQ,IAAI,OAAO,GAAG,IAAI;IAM1B,qBAAqB,IAAI,SAAS,GAAG,IAAI;IAIzC,0BAA0B,IAAI,aAAa,GAAG,IAAI;IAIlD,qBAAqB,CAAC,cAAc,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI;CAqDtE"}
+{"version":3,"file":"transports.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,KAAK,EACX,gCAAgC,EAChC,gCAAgC,EAChC,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAE5B,mDAAmD;AACnD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,sEAAsE;AACtE,eAAO,MAAM,iCAAiC,OAAO,CAAC;AACtD,yEAAyE;AACzE,eAAO,MAAM,iCAAiC,OAAO,CAAC;AAKtD,eAAO,MAAM,aAAa,aAAa,CAAC;AACxC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACpC,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,SAAS;IACzB,cAAc,EAAE,aAAa,CAAC;IAE9B,IAAI,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC/F,IAAI,CACH,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IACxC,IAAI,CACH,OAAO,EAAE,gCAAgC,EACzC,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC,CAAC;IACpD,QAAQ,EAAE,MAAM,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,qBAAa,UAAU;;IAItB;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAQ;IAE/B;;OAEG;IACH,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAS9C,qBAAqB,CAAC,cAAc,EAAE,aAAa,GAAG,IAAI;IAM1D;;;;;OAKG;IACH,aAAa,CAAC,cAAc,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI;IAO/D,QAAQ,IAAI,OAAO,GAAG,IAAI;IAM1B,qBAAqB,IAAI,SAAS,GAAG,IAAI;IAIzC,0BAA0B,IAAI,aAAa,GAAG,IAAI;IAIlD,qBAAqB,CAAC,cAAc,EAAE,aAAa,GAAG,SAAS,GAAG,IAAI;CAqDtE"}

package/dist/actions/transports_http.d.ts

@@ -4,13 +4,13 @@
  * @module
  */
 import type { JsonrpcNotification, JsonrpcRequest, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
-import type { Transport } from './transports.js';
+import type { Transport, TransportSendOptions } from './transports.js';
 export declare class FrontendHttpTransport implements Transport {
     #private;
     readonly transport_name: "frontend_http_rpc";
     constructor(url: string, headers?: Record<string, string>, has_side_effects?: (method: string) => boolean);
-    send(message: JsonrpcRequest): Promise<JsonrpcResponseOrError>;
-    send(message: JsonrpcNotification): Promise<JsonrpcErrorResponse | null>;
+    send(message: JsonrpcRequest, options?: TransportSendOptions): Promise<JsonrpcResponseOrError>;
+    send(message: JsonrpcNotification, options?: TransportSendOptions): Promise<JsonrpcErrorResponse | null>;
     is_ready(): boolean;
 }
 //# sourceMappingURL=transports_http.d.ts.map

package/dist/actions/transports_http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transports_http.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_http.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,KAAK,EAGX,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAE/C,qBAAa,qBAAsB,YAAW,SAAS;;IACtD,QAAQ,CAAC,cAAc,EAAG,mBAAmB,CAAU;gBAOtD,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO;IAOzC,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAC9D,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAuE9E,QAAQ,IAAI,OAAO;CAGnB"}
+{"version":3,"file":"transports_http.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_http.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,KAAK,EAGX,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,SAAS,EAAE,oBAAoB,EAAC,MAAM,iBAAiB,CAAC;AAErE,qBAAa,qBAAsB,YAAW,SAAS;;IACtD,QAAQ,CAAC,cAAc,EAAG,mBAAmB,CAAU;gBAOtD,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO;IAOzC,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAyEvC,QAAQ,IAAI,OAAO;CAGnB"}

package/dist/actions/transports_http.js

@@ -16,7 +16,8 @@ export class FrontendHttpTransport {
         this.#headers = headers ?? { 'content-type': 'application/json', accept: 'application/json' };
         this.#has_side_effects = has_side_effects;
     }
-    async send(message) {
+    async send(message, options) {
+        const signal = options?.signal;
         try {
             let response;
             if (this.#has_side_effects && !this.#has_side_effects(message.method) && 'id' in message) {
@@ -31,6 +32,7 @@ export class FrontendHttpTransport {
                 response = await fetch(`${this.#url}${separator}${search_params.toString()}`, {
                     method: 'GET',
                     headers: this.#headers,
+                    signal,
                 });
             }
             else {
@@ -38,8 +40,7 @@ export class FrontendHttpTransport {
                     method: 'POST',
                     headers: this.#headers,
                     body: JSON.stringify(message),
-                    // TODO
-                    // signal: AbortSignal.timeout(REQUEST_TIMEOUT),
+                    signal,
                 });
             }
             const result = await response.json();

package/dist/actions/transports_ws.d.ts

@@ -1,10 +1,18 @@
 /**
- * WebSocket transport — sends JSON-RPC messages via WebSocket with request tracking.
+ * Frontend WebSocket transport — thin adapter over `WebsocketRpcConnection`.
+ *
+ * Delegates request/response correlation, the durable queue, the heartbeat,
+ * and `AbortSignal`-driven cancel to the underlying connection (the
+ * canonical implementation is `FrontendWebsocketClient`). The transport's
+ * own job is the `Transport` contract: route inbound server-pushed
+ * messages into `peer.receive` and translate the connection's
+ * `Promise<R>`/`ThrownJsonrpcError` shape into `JsonrpcResponseOrError`
+ * envelopes. No parallel pending-request map.
  *
  * @module
  */
-import type { JsonrpcNotification, JsonrpcRequest, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
-import type { Transport } from './transports.js';
+import type { JsonrpcNotification, JsonrpcRequest, JsonrpcRequestId, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
+import type { Transport, TransportSendOptions } from './transports.js';
 /**
  * Minimal interface for a WebSocket connection, decoupled from the concrete Socket Cell.
  */
@@ -14,12 +22,31 @@ export interface WebsocketConnection {
     add_message_handler: (handler: (event: MessageEvent) => void) => () => void;
     add_error_handler: (handler: (event: Event) => void) => () => void;
 }
+/**
+ * RPC-capable WebSocket connection — a `WebsocketConnection` that also
+ * handles request/response correlation with timeout, queue,
+ * `AbortSignal` cancel, and explicit-id support. Required by
+ * `FrontendWebsocketTransport` so it can delegate the pending-map
+ * bookkeeping to one canonical implementation
+ * (`FrontendWebsocketClient`) instead of running a parallel one.
+ *
+ * Consumer wrappers around `FrontendWebsocketClient` (e.g. zzz's
+ * `Socket`) implement this by adding a one-line delegate to the
+ * underlying client's `request`.
+ */
+export interface WebsocketRpcConnection extends WebsocketConnection {
+    request: (method: string, params: unknown, options?: {
+        signal?: AbortSignal;
+        queue?: boolean;
+        id?: JsonrpcRequestId;
+    }) => Promise<unknown>;
+}
 export declare class FrontendWebsocketTransport implements Transport {
     #private;
     readonly transport_name: "frontend_websocket_rpc";
-    constructor(connection: WebsocketConnection, receive: (data: unknown) => Promise<unknown>, request_timeout_ms?: number);
-    send(message: JsonrpcRequest): Promise<JsonrpcResponseOrError>;
-    send(message: JsonrpcNotification): Promise<JsonrpcErrorResponse | null>;
+    constructor(connection: WebsocketRpcConnection, receive: (data: unknown) => Promise<unknown>);
+    send(message: JsonrpcRequest, options?: TransportSendOptions): Promise<JsonrpcResponseOrError>;
+    send(message: JsonrpcNotification, options?: TransportSendOptions): Promise<JsonrpcErrorResponse | null>;
     is_ready(): boolean;
     dispose(): void;
 }

package/dist/actions/transports_ws.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transports_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_ws.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAeH,OAAO,KAAK,EAGX,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAI/C;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC5E,iBAAiB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;CACnE;AAED,qBAAa,0BAA2B,YAAW,SAAS;;IAC3D,QAAQ,CAAC,cAAc,EAAG,wBAAwB,CAAU;gBAS3D,UAAU,EAAE,mBAAmB,EAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,EAC5C,kBAAkB,CAAC,EAAE,MAAM;IAkCtB,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAC9D,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IA8C9E,QAAQ,IAAI,OAAO;IAInB,OAAO,IAAI,IAAI;CAUf"}
+{"version":3,"file":"transports_ws.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAWH,OAAO,KAAK,EAGX,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,SAAS,EAAE,oBAAoB,EAAC,MAAM,iBAAiB,CAAC;AAIrE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;IAC5E,iBAAiB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;CACnE;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IAClE,OAAO,EAAE,CACR,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE;QAAC,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,EAAE,CAAC,EAAE,gBAAgB,CAAA;KAAC,KACpE,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB;AAED,qBAAa,0BAA2B,YAAW,SAAS;;IAC3D,QAAQ,CAAC,cAAc,EAAG,wBAAwB,CAAU;gBAOhD,UAAU,EAAE,sBAAsB,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC;IAyBtF,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAoDvC,QAAQ,IAAI,OAAO;IAInB,OAAO,IAAI,IAAI;CAUf"}

package/dist/actions/transports_ws.js

@@ -1,82 +1,79 @@
 /**
- * WebSocket transport — sends JSON-RPC messages via WebSocket with request tracking.
+ * Frontend WebSocket transport — thin adapter over `WebsocketRpcConnection`.
+ *
+ * Delegates request/response correlation, the durable queue, the heartbeat,
+ * and `AbortSignal`-driven cancel to the underlying connection (the
+ * canonical implementation is `FrontendWebsocketClient`). The transport's
+ * own job is the `Transport` contract: route inbound server-pushed
+ * messages into `peer.receive` and translate the connection's
+ * `Promise<R>`/`ThrownJsonrpcError` shape into `JsonrpcResponseOrError`
+ * envelopes. No parallel pending-request map.
  *
  * @module
  */
-import { ThrownJsonrpcError, jsonrpc_error_messages, UNKNOWN_ERROR_MESSAGE, } from '../http/jsonrpc_errors.js';
-import { is_jsonrpc_notification, is_jsonrpc_request, is_jsonrpc_response, is_jsonrpc_error_response, to_jsonrpc_message_id, create_jsonrpc_error_response, } from '../http/jsonrpc_helpers.js';
-import { RequestTracker } from './request_tracker.svelte.js';
+import { ThrownJsonrpcError, jsonrpc_error_messages } from '../http/jsonrpc_errors.js';
+import { is_jsonrpc_notification, is_jsonrpc_request, to_jsonrpc_message_id, to_jsonrpc_result, create_jsonrpc_response, create_jsonrpc_error_response, } from '../http/jsonrpc_helpers.js';
 export class FrontendWebsocketTransport {
     transport_name = 'frontend_websocket_rpc';
     #connection;
     #receive;
-    #request_tracker;
     #remove_message_handler;
     #remove_error_handler;
-    constructor(connection, receive, request_timeout_ms) {
+    constructor(connection, receive) {
         this.#connection = connection;
         this.#receive = receive;
-        this.#request_tracker = new RequestTracker(request_timeout_ms);
-        // TODO maybe we want to do this setup elsewhere, not hardcoded like this
+        // Inbound dispatch — only server-pushed requests/notifications need
+        // routing here. Responses to requests we sent are correlated by the
+        // connection's own `request()` pending map.
         this.#remove_message_handler = connection.add_message_handler(async (event) => {
             try {
                 const data = JSON.parse(event.data);
-                // TODO the `data.id !== null` check should be refactored, maybe we want the "Error Message Response" concept for non-null ids
-                // Check if this is a response to one of our requests
-                if (is_jsonrpc_response(data) || (is_jsonrpc_error_response(data) && data.id !== null)) {
-                    // This is a response to a request we sent
-                    this.#request_tracker.handle_message(data);
-                }
-                else if (is_jsonrpc_request(data) || is_jsonrpc_notification(data)) {
-                    // This is a new request/notification from the server
+                if (is_jsonrpc_request(data) || is_jsonrpc_notification(data)) {
                     await this.#receive(data);
                 }
-                else {
-                    console.warn('[ws_transport] received unknown message type:', data);
-                }
+                // Responses are owned by `connection.request()` — ignore here.
             }
             catch (error) {
                 console.error('[ws_transport] error parsing WebSocket message:', error);
-                // TODO maybe send the whole thing back wrapped in an error?
-                // can't reference anything else for a response
             }
         });
         this.#remove_error_handler = connection.add_error_handler((event) => {
             console.error('[ws_transport] WebSocket error:', event);
         });
     }
-    async send(message) {
+    async send(message, options) {
+        // Fail-fast at the transport boundary. The connection's own queue
+        // would buffer the request and flush on reconnect; that's the right
+        // default for direct `client.request()` callers but the typed Proxy
+        // path expects "service unavailable" semantics when the WS is down.
         if (!this.is_ready()) {
             return create_jsonrpc_error_response(to_jsonrpc_message_id(message), jsonrpc_error_messages.service_unavailable('WebSocket not connected'));
         }
-        try {
-            // If this is a JSON-RPC request with an id (not a notification), set up request tracking.
-            if (is_jsonrpc_request(message)) {
-                // TODO track the whole request?
-                const deferred = this.#request_tracker.track_request(message.id);
-                this.#connection.send(message);
-                // Return the promise that will resolve when the response is received
-                const result = await deferred.promise;
-                return result;
+        if (is_jsonrpc_request(message)) {
+            try {
+                const result = await this.#connection.request(message.method, message.params, {
+                    id: message.id,
+                    signal: options?.signal,
+                    queue: false,
+                });
+                return create_jsonrpc_response(message.id, to_jsonrpc_result(result));
             }
-            else if (is_jsonrpc_notification(message)) {
-                // For notifications, just send without tracking
-                this.#connection.send(message);
-                return null;
+            catch (error) {
+                if (error instanceof ThrownJsonrpcError) {
+                    return create_jsonrpc_error_response(message.id, {
+                        code: error.code,
+                        message: error.message,
+                        data: error.data,
+                    });
+                }
+                return create_jsonrpc_error_response(message.id, jsonrpc_error_messages.internal_error(error instanceof Error ? error.message : String(error)));
             }
-            // Invalid message type - return error with id if available
-            return create_jsonrpc_error_response(to_jsonrpc_message_id(message), jsonrpc_error_messages.invalid_request());
         }
-        catch (error) {
-            if (error instanceof ThrownJsonrpcError) {
-                return create_jsonrpc_error_response(to_jsonrpc_message_id(message), {
-                    code: error.code,
-                    message: error.message,
-                    data: error.data,
-                });
-            }
-            return create_jsonrpc_error_response(to_jsonrpc_message_id(message), jsonrpc_error_messages.internal_error(error.message || UNKNOWN_ERROR_MESSAGE));
+        if (is_jsonrpc_notification(message)) {
+            this.#connection.send(message);
+            return null;
         }
+        return create_jsonrpc_error_response(to_jsonrpc_message_id(message), jsonrpc_error_messages.invalid_request());
     }
     is_ready() {
         return this.#connection.connected;

package/dist/actions/transports_ws_backend.d.ts

@@ -7,7 +7,7 @@
 import type { WSContext } from 'hono/ws';
 import type { JsonrpcMessageFromServerToClient, JsonrpcNotification, JsonrpcRequest, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
 import { type Uuid } from '../uuid.js';
-import { type Transport } from './transports.js';
+import { type Transport, type TransportSendOptions } from './transports.js';
 /**
  * Auth identity attached to a single WebSocket connection.
  *
@@ -78,8 +78,8 @@ export declare class BackendWebsocketTransport implements FilterableBroadcastTra
      * @returns the number of sockets closed
      */
     close_sockets_for_token(api_token_id: string): number;
-    send(message: JsonrpcRequest): Promise<JsonrpcResponseOrError>;
-    send(message: JsonrpcNotification): Promise<JsonrpcErrorResponse | null>;
+    send(message: JsonrpcRequest, options?: TransportSendOptions): Promise<JsonrpcResponseOrError>;
+    send(message: JsonrpcNotification, options?: TransportSendOptions): Promise<JsonrpcErrorResponse | null>;
     /**
      * Broadcast to connections whose identity satisfies a predicate.
      *
@@ -92,5 +92,14 @@ export declare class BackendWebsocketTransport implements FilterableBroadcastTra
      */
     broadcast_filtered(message: JsonrpcMessageFromServerToClient, predicate: (identity: ConnectionIdentity) => boolean): number;
     is_ready(): boolean;
+    /**
+     * Number of currently tracked WebSocket connections.
+     *
+     * Read-only counter intended for telemetry, logging, and tests.
+     * Counts every entry in the connection map — including connections
+     * that have been closed by the peer but not yet removed by the WS
+     * adapter's `onClose` callback.
+     */
+    get_connection_count(): number;
 }
 //# sourceMappingURL=transports_ws_backend.d.ts.map

package/dist/actions/transports_ws_backend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transports_ws_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_ws_backend.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAC;AAEvC,OAAO,KAAK,EAEX,gCAAgC,EAChC,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAO5B,OAAO,EAAc,KAAK,IAAI,EAAC,MAAM,YAAY,CAAC;AAClD,OAAO,EAA2B,KAAK,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAIzE;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAClC,sEAAsE;IACtE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,4CAA4C;IAC5C,UAAU,EAAE,IAAI,CAAC;IACjB,sEAAsE;IACtE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,4BAA6B,SAAQ,SAAS;IAC9D,kBAAkB,EAAE,CACnB,OAAO,EAAE,gCAAgC,EACzC,SAAS,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,OAAO,KAChD,MAAM,CAAC;CACZ;AAED,qDAAqD;AACrD,eAAO,MAAM,iCAAiC,GAC7C,WAAW,SAAS,KAClB,SAAS,IAAI,4BAEqE,CAAC;AAEtF,qBAAa,yBAA0B,YAAW,4BAA4B;;IAC7E,QAAQ,CAAC,cAAc,EAAG,uBAAuB,CAAU;IAY3D;;;;;;;;OAQG;IACH,cAAc,CACb,EAAE,EAAE,SAAS,EACb,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,UAAU,EAAE,IAAI,EAChB,YAAY,GAAE,MAAM,GAAG,IAAW,GAChC,IAAI;IAQP;;;OAGG;IACH,iBAAiB,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IA0BtC;;;;OAIG;IACH,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAIrD;;;;OAIG;IACH,yBAAyB,CAAC,UAAU,EAAE,IAAI,GAAG,MAAM;IAInD;;;;;;;;OAQG;IACH,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAsB/C,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAC9D,IAAI,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IA4C9E;;;;;;;;;OASG;IACH,kBAAkB,CACjB,OAAO,EAAE,gCAAgC,EACzC,SAAS,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,OAAO,GAClD,MAAM;IAoBT,QAAQ,IAAI,OAAO;CAGnB"}
+{"version":3,"file":"transports_ws_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_ws_backend.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,SAAS,CAAC;AAEvC,OAAO,KAAK,EAEX,gCAAgC,EAChC,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAO5B,OAAO,EAAc,KAAK,IAAI,EAAC,MAAM,YAAY,CAAC;AAClD,OAAO,EAA2B,KAAK,SAAS,EAAE,KAAK,oBAAoB,EAAC,MAAM,iBAAiB,CAAC;AAIpG;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAClC,sEAAsE;IACtE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,4CAA4C;IAC5C,UAAU,EAAE,IAAI,CAAC;IACjB,sEAAsE;IACtE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,4BAA6B,SAAQ,SAAS;IAC9D,kBAAkB,EAAE,CACnB,OAAO,EAAE,gCAAgC,EACzC,SAAS,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,OAAO,KAChD,MAAM,CAAC;CACZ;AAED,qDAAqD;AACrD,eAAO,MAAM,iCAAiC,GAC7C,WAAW,SAAS,KAClB,SAAS,IAAI,4BAEqE,CAAC;AAEtF,qBAAa,yBAA0B,YAAW,4BAA4B;;IAC7E,QAAQ,CAAC,cAAc,EAAG,uBAAuB,CAAU;IAY3D;;;;;;;;OAQG;IACH,cAAc,CACb,EAAE,EAAE,SAAS,EACb,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,UAAU,EAAE,IAAI,EAChB,YAAY,GAAE,MAAM,GAAG,IAAW,GAChC,IAAI;IAQP;;;OAGG;IACH,iBAAiB,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IA0BtC;;;;OAIG;IACH,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAIrD;;;;OAIG;IACH,yBAAyB,CAAC,UAAU,EAAE,IAAI,GAAG,MAAM;IAInD;;;;;;;;OAQG;IACH,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM;IAsB/C,IAAI,CACT,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,sBAAsB,CAAC;IAC5B,IAAI,CACT,OAAO,EAAE,mBAAmB,EAC5B,OAAO,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IA6CvC;;;;;;;;;OASG;IACH,kBAAkB,CACjB,OAAO,EAAE,gCAAgC,EACzC,SAAS,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,OAAO,GAClD,MAAM;IAoBT,QAAQ,IAAI,OAAO;IAInB;;;;;;;OAOG;IACH,oBAAoB,IAAI,MAAM;CAG9B"}

package/dist/actions/transports_ws_backend.js

@@ -107,7 +107,7 @@ export class BackendWebsocketTransport {
         this.#cleanup_connection(connection_id, ws);
         ws.close(WS_CLOSE_SESSION_REVOKED, 'Session revoked');
     }
-    async send(message) {
+    async send(message, _options) {
         // TODO currently just broadcasts all messages to all clients, the transport abstraction is still a WIP
         if (is_jsonrpc_request(message)) {
             return create_jsonrpc_error_response(message.id, 
@@ -170,4 +170,15 @@ export class BackendWebsocketTransport {
     is_ready() {
         return this.#connections.size > 0;
     }
+    /**
+     * Number of currently tracked WebSocket connections.
+     *
+     * Read-only counter intended for telemetry, logging, and tests.
+     * Counts every entry in the connection map — including connections
+     * that have been closed by the peer but not yet removed by the WS
+     * adapter's `onClose` callback.
+     */
+    get_connection_count() {
+        return this.#connections.size;
+    }
 }

package/dist/auth/bearer_auth.js

@@ -50,7 +50,6 @@ export const create_bearer_auth_middleware = (deps, ip_rate_limiter, log) => {
         // Case-insensitive scheme matching per RFC 7235 §2.1 — defense-in-depth:
         // without this, a `bearer` (lowercase) header silently bypasses token
         // validation and browser-context rejection instead of being processed.
-        // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
         if (!auth_header || auth_header.slice(0, 7).toLowerCase() !== 'bearer ') {
             await next();
             return;

package/dist/auth/keyring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyring.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/auth/keyring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH;;;GAGG;AACH,MAAM,WAAW,OAAO;IACvB;;;OAGG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzC;;;;OAIG;IACH,MAAM,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAAC;CACrF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,GAAI,WAAW,MAAM,GAAG,SAAS,KAAG,OAAO,GAAG,IAkCxE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,GAAG,SAAS,KAAG,KAAK,CAAC,MAAM,CAc5E,CAAC;AA6CF;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAC/B;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,GAC5B;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAAC,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GAAI,WAAW,MAAM,GAAG,SAAS,KAAG,sBAUxE,CAAC"}
+{"version":3,"file":"keyring.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/auth/keyring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH;;;GAGG;AACH,MAAM,WAAW,OAAO;IACvB;;;OAGG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzC;;;;OAIG;IACH,MAAM,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CAAC;CACrF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,GAAI,WAAW,MAAM,GAAG,SAAS,KAAG,OAAO,GAAG,IAiCxE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,MAAM,GAAG,SAAS,KAAG,KAAK,CAAC,MAAM,CAc5E,CAAC;AA6CF;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAC/B;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,GAC5B;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CAAC,CAAC;AAEtC;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,GAAI,WAAW,MAAM,GAAG,SAAS,KAAG,sBAUxE,CAAC"}

package/dist/auth/keyring.js

@@ -58,9 +58,7 @@ export const create_keyring = (env_value) => {
         },
         async verify(signed_value) {
             for (let i = 0; i < secrets.length; i++) {
-                // eslint-disable-next-line no-await-in-loop
                 const key = await get_key(i);
-                // eslint-disable-next-line no-await-in-loop
                 const result = await verify_with_crypto_key(signed_value, key);
                 if (result !== false) {
                     return { value: result, key_index: i };

package/dist/auth/migrations.js

@@ -49,23 +49,23 @@ export const AUTH_MIGRATIONS = [
             await db.query(ACTOR_INDEX);
             await db.query(PERMIT_SCHEMA);
             for (const sql of PERMIT_INDEXES) {
-                await db.query(sql); // eslint-disable-line no-await-in-loop
+                await db.query(sql);
             }
             await db.query(AUTH_SESSION_SCHEMA);
             for (const sql of AUTH_SESSION_INDEXES) {
-                await db.query(sql); // eslint-disable-line no-await-in-loop
+                await db.query(sql);
             }
             await db.query(API_TOKEN_SCHEMA);
             await db.query(API_TOKEN_INDEX);
             await db.query(AUDIT_LOG_SCHEMA);
             for (const sql of AUDIT_LOG_INDEXES) {
-                await db.query(sql); // eslint-disable-line no-await-in-loop
+                await db.query(sql);
             }
             await db.query(BOOTSTRAP_LOCK_SCHEMA);
             await db.query(BOOTSTRAP_LOCK_SEED);
             await db.query(INVITE_SCHEMA);
             for (const sql of INVITE_INDEXES) {
-                await db.query(sql); // eslint-disable-line no-await-in-loop
+                await db.query(sql);
             }
             await db.query(APP_SETTINGS_SCHEMA);
             await db.query(APP_SETTINGS_SEED);

package/dist/db/migrate.d.ts

@@ -3,7 +3,11 @@
  *
  * Migrations are functions in ordered arrays, grouped by namespace.
  * A `schema_version` table tracks progress per namespace.
- * Each migration runs in its own transaction.
+ *
+ * **Chain-level transactions**: All pending migrations in a namespace run in a
+ * single transaction. Any failure rolls back every migration in that run —
+ * no partial-state recovery. This rules out non-transactional DDL (e.g.,
+ * `CREATE INDEX CONCURRENTLY`); run those out of band.
  *
  * **Forward-only**: No down-migrations. Schema changes are additive.
  * For pre-release development, collapse migrations into a single v0.
@@ -53,9 +57,15 @@ export interface MigrationResult {
  *
  * Creates the `schema_version` tracking table if it does not exist,
  * then for each namespace: acquires an advisory lock, reads the current
- * version, runs pending migrations in order (each in its own transaction),
+ * version, runs all pending migrations in order inside a single transaction,
  * updates the stored version, and releases the lock.
  *
+ * **Atomicity**: The pending chain for each namespace runs in one transaction —
+ * any failure rolls back every migration that ran in that invocation. The
+ * next run starts from the previously-stored version, re-running the whole
+ * (fixed) chain. Namespaces are independent: a later namespace's failure
+ * does not roll back an earlier namespace that already committed.
+ *
  * **Concurrency**: Uses PostgreSQL advisory locks to serialize concurrent
  * callers on the same namespace. Safe for multi-instance deployments.
  *

package/dist/db/migrate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrate.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/migrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,SAAS,CAAC;AAEhC;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEpD;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,WAAW,CAAA;CAAC,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CAC7B;AAED,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;CAC3B;AA8BD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GAC1B,IAAI,EAAE,EACN,YAAY,KAAK,CAAC,kBAAkB,CAAC,KACnC,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,CA2EhC,CAAC"}
+{"version":3,"file":"migrate.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/migrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAC,EAAE,EAAC,MAAM,SAAS,CAAC;AAEhC;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEpD;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,WAAW,CAAA;CAAC,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CAC7B;AAED,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;CAC3B;AA8BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,cAAc,GAC1B,IAAI,EAAE,EACN,YAAY,KAAK,CAAC,kBAAkB,CAAC,KACnC,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,CA0EhC,CAAC"}