@fuzdev/fuz_app 0.10.1 → 0.11.0

package/dist/actions/request_tracker.svelte.js

@@ -0,0 +1,161 @@
+/**
+ * Request tracker — manages pending JSON-RPC requests with timeouts.
+ *
+ * Uses SvelteMap for reactive pending request tracking.
+ *
+ * @module
+ */
+import { create_deferred } from '@fuzdev/fuz_util/async.js';
+import { SvelteMap } from 'svelte/reactivity';
+import { JSONRPC_INTERNAL_ERROR, } from '../http/jsonrpc.js';
+import { ThrownJsonrpcError, JSONRPC_ERROR_CODES } from '../http/jsonrpc_errors.js';
+const get_datetime_now = () => new Date().toISOString();
+// TODO what if this uses a tracker id param that's an opaque UUID but can be used for action association?
+// TODO name, like `TrackedRequest`? or is this implicit namespacing and generic name preferred
+/**
+ * Represents a pending request with its associated state.
+ */
+export class RequestTrackerItem {
+    id;
+    deferred;
+    created;
+    status = $state.raw();
+    timeout = $state.raw();
+    constructor(id, deferred, created, status, timeout) {
+        this.id = id;
+        this.deferred = deferred;
+        this.created = created;
+        this.status = status;
+        this.timeout = timeout;
+    }
+}
+/**
+ * Tracks JSON-RPC requests and their responses to manage promises and timeouts.
+ * Used by transports to handle the request-response lifecycle.
+ */
+export class RequestTracker {
+    pending_requests = new SvelteMap();
+    request_timeout_ms;
+    constructor(request_timeout_ms = 120_000) {
+        this.request_timeout_ms = request_timeout_ms;
+    }
+    /**
+     * Track a new request with the given id.
+     * @param id - the request id
+     * @returns a deferred promise that will be resolved when the response is received
+     */
+    track_request(id) {
+        const deferred = create_deferred();
+        const created = get_datetime_now();
+        // If we're tracking a request with the same id, clean up the previous one first
+        const existing_request = this.pending_requests.get(id);
+        if (existing_request?.timeout) {
+            clearTimeout(existing_request.timeout);
+        }
+        // Set up a timeout to automatically reject the request after a delay
+        const timeout = setTimeout(() => {
+            // Create a proper timeout error message
+            this.reject_request(id, {
+                jsonrpc: '2.0',
+                id,
+                error: { code: JSONRPC_INTERNAL_ERROR, message: `request timed out: ${id}` },
+            });
+        }, this.request_timeout_ms);
+        // Store the request tracker using the new class
+        this.pending_requests.set(id, new RequestTrackerItem(id, deferred, created, 'pending', timeout));
+        return deferred;
+    }
+    /**
+     * Resolve a pending request with the given response data.
+     * @param id - the request id
+     * @param response - the response data
+     */
+    resolve_request(id, response) {
+        const request = this.pending_requests.get(id);
+        if (!request) {
+            console.warn(`received response for unknown request: ${id}`);
+            return;
+        }
+        // Clear the timeout and resolve the promise
+        if (request.timeout) {
+            clearTimeout(request.timeout);
+            request.timeout = undefined;
+        }
+        request.status = 'success';
+        request.deferred.resolve(response);
+        this.pending_requests.delete(id);
+    }
+    /**
+     * Rejects a pending request with the given error.
+     * @param id - the request id
+     * @param error_message - the complete `JsonrpcErrorResponse` object
+     */
+    reject_request(id, error_message) {
+        const request = this.pending_requests.get(id);
+        if (!request) {
+            console.warn(`received error for unknown request: ${id}`);
+            return;
+        }
+        // Clear the timeout and reject the promise
+        if (request.timeout) {
+            clearTimeout(request.timeout);
+            request.timeout = undefined;
+        }
+        request.status = 'failure';
+        const error = new ThrownJsonrpcError(error_message.error.code, error_message.error.message, error_message.error.data);
+        request.deferred.reject(error);
+        this.pending_requests.delete(id);
+    }
+    /**
+     * Handles an incoming JSON-RPC message. Resolves or rejects the associated request.
+     * Ignores notifications and unknown/invalid messages.
+     */
+    handle_message(message) {
+        if (!message)
+            return; // ignore invalid values
+        const { id } = message;
+        // TODO maybe log a warning/error?
+        if (id == null)
+            return; // ignore notifications and errors without ids
+        // JSON-RPC responses require both an `id` and either a `result` or `error` field, but not both
+        if ('result' in message) {
+            this.resolve_request(id, message);
+        }
+        else if ('error' in message) {
+            this.reject_request(id, message);
+        }
+        // ignore other messages
+    }
+    /**
+     * Cancel a pending request.
+     * @param id - the request id
+     */
+    cancel_request(id) {
+        const request = this.pending_requests.get(id);
+        if (!request) {
+            return;
+        }
+        if (request.timeout) {
+            clearTimeout(request.timeout);
+            request.timeout = undefined;
+        }
+        // We don't reject the promise here, just clean up the tracking
+        this.pending_requests.delete(id);
+    }
+    /**
+     * Cancel all pending requests.
+     * @param reason - optional reason to include in rejection
+     */
+    cancel_all_requests(reason) {
+        for (const [id, request] of this.pending_requests.entries()) {
+            if (request.timeout) {
+                clearTimeout(request.timeout);
+                request.timeout = undefined;
+            }
+            request.status = 'failure';
+            request.deferred.reject(new ThrownJsonrpcError(JSONRPC_ERROR_CODES.internal_error, // TODO canceled error?
+            reason || 'request cancelled'));
+            this.pending_requests.delete(id);
+        }
+    }
+}

package/dist/actions/rpc_client.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Typed RPC client — creates a Proxy-based API from action specs.
+ *
+ * Two tiers of usage:
+ * - **Tier 1** (simple, for tx): transport send/receive, Result return. No `environment`.
+ * - **Tier 2** (full, for zzz): ActionEvent lifecycle with `environment`.
+ *
+ * Consumers cast the return to their generated `ActionsApi` interface for full type safety.
+ *
+ * @module
+ */
+import type { ActionEventEnvironment } from './action_event_types.js';
+import type { ActionPeer } from './action_peer.js';
+import type { ActionEventDataUnion } from './action_event_data.js';
+/** Duck-typed action history — consumers pass their concrete Actions cell. */
+export interface RpcClientActionHistory {
+    add_from_json: (json: {
+        method: string;
+        action_event_data: ActionEventDataUnion;
+    }) => {
+        listen_to_action_event: (event: any) => void;
+    } | undefined;
+}
+/** Options for `create_rpc_client`. */
+export interface CreateRpcClientOptions {
+    peer: ActionPeer;
+    environment: ActionEventEnvironment;
+    /** Optional action history tracking (duck-typed Actions cell). */
+    actions?: RpcClientActionHistory;
+}
+/**
+ * Creates a Proxy-based API from action specs.
+ *
+ * Method calls are dynamically dispatched based on the action spec's kind:
+ * - `request_response` → send request, await response, return Result
+ * - `remote_notification` → send notification, return Result
+ * - `local_call` → execute locally (sync or async), return Result or throw
+ *
+ * @param options - client options (peer, environment, optional action history)
+ * @returns a Proxy that responds to any method name found in the environment's specs
+ */
+export declare const create_rpc_client: (options: CreateRpcClientOptions) => Record<string, (...args: Array<any>) => any>;
+//# sourceMappingURL=rpc_client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rpc_client.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/rpc_client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,yBAAyB,CAAC;AAOpE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAMjE,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB;IACtC,aAAa,EAAE,CAAC,IAAI,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,oBAAoB,CAAA;KAAC,KAC5E;QACA,sBAAsB,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;KAC5C,GACD,SAAS,CAAC;CACb;AAED,uCAAuC;AACvC,MAAM,WAAW,sBAAsB;IACtC,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,sBAAsB,CAAC;IACpC,kEAAkE;IAClE,OAAO,CAAC,EAAE,sBAAsB,CAAC;CACjC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC7B,SAAS,sBAAsB,KAC7B,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,CAgB7C,CAAC"}

package/dist/actions/rpc_client.js

@@ -0,0 +1,151 @@
+/**
+ * Typed RPC client — creates a Proxy-based API from action specs.
+ *
+ * Two tiers of usage:
+ * - **Tier 1** (simple, for tx): transport send/receive, Result return. No `environment`.
+ * - **Tier 2** (full, for zzz): ActionEvent lifecycle with `environment`.
+ *
+ * Consumers cast the return to their generated `ActionsApi` interface for full type safety.
+ *
+ * @module
+ */
+import { create_action_event } from './action_event.js';
+import { is_send_request, is_notification_send, extract_action_result, } from './action_event_helpers.js';
+/**
+ * Creates a Proxy-based API from action specs.
+ *
+ * Method calls are dynamically dispatched based on the action spec's kind:
+ * - `request_response` → send request, await response, return Result
+ * - `remote_notification` → send notification, return Result
+ * - `local_call` → execute locally (sync or async), return Result or throw
+ *
+ * @param options - client options (peer, environment, optional action history)
+ * @returns a Proxy that responds to any method name found in the environment's specs
+ */
+export const create_rpc_client = (options) => {
+    const { peer, environment, actions } = options;
+    return new Proxy({}, {
+        get(_target, method) {
+            const spec = environment.lookup_action_spec(method);
+            if (!spec) {
+                return undefined;
+            }
+            return create_action_method(peer, environment, spec, actions);
+        },
+        has(_target, method) {
+            return environment.lookup_action_spec(method) !== undefined;
+        },
+    });
+};
+/**
+ * Creates a method that executes an action through its complete lifecycle.
+ */
+const create_action_method = (peer, environment, spec, actions) => {
+    switch (spec.kind) {
+        case 'local_call':
+            return spec.async
+                ? create_async_local_call_method(environment, spec, actions)
+                : create_sync_local_call_method(environment, spec, actions);
+        case 'request_response':
+            return create_request_response_method(peer, environment, spec, actions);
+        case 'remote_notification':
+            return create_remote_notification_method(peer, environment, spec, actions);
+    }
+};
+/**
+ * Creates a synchronous local call method.
+ * Returns value directly - can throw on error (sync methods cannot return Result).
+ */
+const create_sync_local_call_method = (environment, spec, actions) => {
+    return (input) => {
+        const event = create_action_event(environment, spec, input);
+        const action = actions?.add_from_json({
+            method: spec.method,
+            action_event_data: event.toJSON(),
+        });
+        action?.listen_to_action_event(event);
+        event.parse().handle_sync();
+        const result = extract_action_result(event);
+        if (result.ok) {
+            return result.value;
+        }
+        else {
+            // Sync methods must throw on error (cannot return Result synchronously)
+            throw new Error(`${spec.method} failed: ${result.error.message}`);
+        }
+    };
+};
+/**
+ * Creates an asynchronous local call method.
+ * Returns Result for type-safe error handling.
+ */
+const create_async_local_call_method = (environment, spec, actions) => {
+    return async (input) => {
+        const event = create_action_event(environment, spec, input);
+        const action = actions?.add_from_json({
+            method: spec.method,
+            action_event_data: event.toJSON(),
+        });
+        action?.listen_to_action_event(event);
+        await event.parse().handle_async();
+        return extract_action_result(event);
+    };
+};
+/**
+ * Creates a request/response method that communicates over the network.
+ */
+const create_request_response_method = (peer, environment, spec, actions) => {
+    return async (input) => {
+        const event = create_action_event(environment, spec, input);
+        const action = actions?.add_from_json({
+            method: spec.method,
+            action_event_data: event.toJSON(),
+        });
+        action?.listen_to_action_event(event);
+        await event.parse().handle_async();
+        // Check if we're in send_error phase before type narrowing
+        if (event.data.kind === 'request_response' && event.data.phase === 'send_error') {
+            await event.handle_async(); // Call send_error handler
+            return extract_action_result(event);
+        }
+        if (!is_send_request(event.data))
+            throw Error(); // TODO @many maybe make this an assertion helper?
+        if (event.data.step !== 'handled') {
+            return extract_action_result(event);
+        }
+        const response = await peer.send(event.data.request);
+        event.transition('receive_response');
+        // TODO @api shouldn't this happen in the peer like the other method calls?
+        event.set_response(response);
+        event.parse(); // May transition to receive_error
+        await event.handle_async();
+        return extract_action_result(event);
+    };
+};
+/**
+ * Creates a remote notification method (fire and forget).
+ * Returns Result<{value: void}> for consistency.
+ */
+const create_remote_notification_method = (peer, environment, spec, actions) => {
+    return async (input) => {
+        const event = create_action_event(environment, spec, input);
+        const action = actions?.add_from_json({
+            method: spec.method,
+            action_event_data: event.toJSON(),
+        });
+        action?.listen_to_action_event(event);
+        await event.parse().handle_async();
+        if (!is_notification_send(event.data))
+            throw Error(); // TODO @many maybe make this an assertion helper?
+        if (event.data.step === 'handled') {
+            const send_result = await peer.send(event.data.notification);
+            // Check if notification failed to send
+            if (send_result !== null) {
+                environment.log?.error('notification send failed:', send_result.error);
+                return { ok: false, error: send_result.error };
+            }
+            return { ok: true, value: undefined };
+        }
+        return extract_action_result(event);
+    };
+};

package/dist/actions/transports.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Transport abstraction for action communication.
+ *
+ * Provides the `Transport` interface and `Transports` registry for managing
+ * multiple transports with fallback behavior.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import type { JsonrpcMessageFromClientToServer, JsonrpcMessageFromServerToClient, JsonrpcNotification, JsonrpcRequest, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
+/** WebSocket close code for session revocation. */
+export declare const WS_CLOSE_SESSION_REVOKED = 4001;
+export declare const TransportName: z.ZodString;
+export type TransportName = z.infer<typeof TransportName>;
+export interface Transport {
+    transport_name: TransportName;
+    send(message: JsonrpcRequest): Promise<JsonrpcResponseOrError>;
+    send(message: JsonrpcNotification): Promise<JsonrpcErrorResponse | null>;
+    send(message: JsonrpcMessageFromClientToServer): Promise<JsonrpcMessageFromServerToClient | null>;
+    is_ready: () => boolean;
+    dispose?: () => void;
+}
+export declare class Transports {
+    #private;
+    /**
+     * Whether to allow fallback to other transports if the current one is not available.
+     * @default true
+     */
+    allow_fallback: boolean;
+    /**
+     * Registers a transport.
+     */
+    register_transport(transport: Transport): void;
+    set_current_transport(transport_name: TransportName): void;
+    /**
+     * Gets either the current transport or the first ready transport
+     * depending on `allow_fallback`, or throws an error.
+     * @param transport_name - optional transport to use instead of the current
+     * @throws when no transport available or ready
+     */
+    get_transport(transport_name?: TransportName): Transport | null;
+    is_ready(): boolean | null;
+    get_current_transport(): Transport | null;
+    get_current_transport_name(): TransportName | null;
+    get_transport_by_name(transport_name: TransportName): Transport | null;
+}
+//# sourceMappingURL=transports.d.ts.map

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

@@ -0,0 +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;AACtB,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;AAK7C,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"}

package/dist/actions/transports.js

@@ -0,0 +1,108 @@
+/**
+ * Transport abstraction for action communication.
+ *
+ * Provides the `Transport` interface and `Transports` registry for managing
+ * multiple transports with fallback behavior.
+ *
+ * @module
+ */
+import { z } from 'zod';
+/** WebSocket close code for session revocation. */
+export const WS_CLOSE_SESSION_REVOKED = 4001;
+// TODO figure out the symmetry of frontend and backend transports (none/partial/full?) --
+// we may also need orthogonal abstractions to clarify the transport role
+export const TransportName = z.string(); // not branded for convenience, will just error at runtime, the schema is just for docs atm
+export class Transports {
+    #current_transport = null;
+    #transport_by_name = new Map();
+    /**
+     * Whether to allow fallback to other transports if the current one is not available.
+     * @default true
+     */
+    allow_fallback = true; // TODO allow registering transports with a priority level so this can be customized
+    /**
+     * Registers a transport.
+     */
+    register_transport(transport) {
+        this.#transport_by_name.set(transport.transport_name, transport); // TODO maybe ensure unregistering of any previous transport?
+        // Set current transport if not already set
+        if (!this.#current_transport) {
+            this.#current_transport = transport;
+        }
+    }
+    set_current_transport(transport_name) {
+        const transport = this.#transport_by_name.get(transport_name);
+        if (!transport)
+            throw new Error(`transport not registered: ${transport_name}`);
+        this.#current_transport = transport;
+    }
+    /**
+     * Gets either the current transport or the first ready transport
+     * depending on `allow_fallback`, or throws an error.
+     * @param transport_name - optional transport to use instead of the current
+     * @throws when no transport available or ready
+     */
+    get_transport(transport_name) {
+        return this.allow_fallback
+            ? this.#get_first_ready(transport_name)
+            : this.#get_exact(transport_name);
+    }
+    // TODO these 4 arent used yet but seem useful? `get_transport` is the main method
+    is_ready() {
+        const transport = this.#current_transport;
+        if (!transport)
+            return null;
+        return transport.is_ready();
+    }
+    get_current_transport() {
+        return this.#current_transport ?? null;
+    }
+    get_current_transport_name() {
+        return this.#current_transport?.transport_name ?? null;
+    }
+    get_transport_by_name(transport_name) {
+        return this.#transport_by_name.get(transport_name) ?? null;
+    }
+    /**
+     * Gets the specified transport, defaulting to the current, or throws an error.
+     * @param transport_name - optional transport type to use instead of the current
+     * @throws when no transport available or ready
+     */
+    #get_exact(transport_name) {
+        const transport = transport_name
+            ? this.#transport_by_name.get(transport_name)
+            : this.#current_transport;
+        if (transport?.is_ready()) {
+            return transport;
+        }
+        return null;
+    }
+    /**
+     * Gets the appropriate transport or throws an error.
+     * @param transport_name - optional transport type or array of types to use instead of the current
+     * @throws when no transport available or ready
+     */
+    #get_first_ready(transport_name) {
+        // First try the specified transport(s) if provided
+        if (transport_name) {
+            const transport_names = Array.isArray(transport_name) ? transport_name : [transport_name];
+            for (const transport_name of transport_names) {
+                const transport = this.#transport_by_name.get(transport_name);
+                if (transport?.is_ready()) {
+                    return transport;
+                }
+            }
+        }
+        // Then try the current transport if it's ready
+        if (this.#current_transport?.is_ready()) {
+            return this.#current_transport;
+        }
+        // Finally, try any other available transport
+        for (const transport of this.#transport_by_name.values()) {
+            if (transport.is_ready()) {
+                return transport;
+            }
+        }
+        return null;
+    }
+}

package/dist/actions/transports_http.d.ts

@@ -0,0 +1,16 @@
+/**
+ * HTTP transport — sends JSON-RPC messages via HTTP POST (or GET for reads).
+ *
+ * @module
+ */
+import type { JsonrpcNotification, JsonrpcRequest, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
+import type { Transport } 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>;
+    is_ready(): boolean;
+}
+//# sourceMappingURL=transports_http.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transports_http.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/actions/transports_http.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAcH,OAAO,KAAK,EAGX,mBAAmB,EACnB,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,oBAAoB,CAAC;AAE5B,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"}

package/dist/actions/transports_http.js

@@ -0,0 +1,81 @@
+/**
+ * HTTP transport — sends JSON-RPC messages via HTTP POST (or GET for reads).
+ *
+ * @module
+ */
+import { DEV } from 'esm-env';
+import { ThrownJsonrpcError, jsonrpc_error_messages, http_status_to_jsonrpc_error_code, UNKNOWN_ERROR_MESSAGE, } from '../http/jsonrpc_errors.js';
+import { create_jsonrpc_error_response, to_jsonrpc_message_id, is_jsonrpc_error_response, } from '../http/jsonrpc_helpers.js';
+export class FrontendHttpTransport {
+    transport_name = 'frontend_http_rpc';
+    #url;
+    #headers;
+    #has_side_effects;
+    constructor(url, headers, has_side_effects) {
+        this.#url = url;
+        this.#headers = headers ?? { 'content-type': 'application/json', accept: 'application/json' };
+        this.#has_side_effects = has_side_effects;
+    }
+    async send(message) {
+        try {
+            let response;
+            if (this.#has_side_effects && !this.#has_side_effects(message.method) && 'id' in message) {
+                // GET for read-only actions (matching fuz_app's create_rpc_endpoint GET convention)
+                const search_params = new URLSearchParams();
+                search_params.set('method', message.method);
+                search_params.set('id', String(message.id));
+                if (message.params !== undefined) {
+                    search_params.set('params', JSON.stringify(message.params));
+                }
+                const separator = this.#url.includes('?') ? '&' : '?';
+                response = await fetch(`${this.#url}${separator}${search_params.toString()}`, {
+                    method: 'GET',
+                    headers: this.#headers,
+                });
+            }
+            else {
+                response = await fetch(this.#url, {
+                    method: 'POST',
+                    headers: this.#headers,
+                    body: JSON.stringify(message),
+                    // TODO
+                    // signal: AbortSignal.timeout(REQUEST_TIMEOUT),
+                });
+            }
+            const result = await response.json();
+            // For JSON-RPC, we always expect a 200 OK response.
+            // The actual error will be in the JSON-RPC error field.
+            if (!response.ok) {
+                return create_jsonrpc_error_response(to_jsonrpc_message_id(message), {
+                    code: http_status_to_jsonrpc_error_code(response.status),
+                    message: `HTTP error: ${response.status} ${response.statusText}`,
+                });
+            }
+            // In development, check if we got a JSON-RPC error with HTTP 200
+            // and verify the error code matches the expected HTTP status.
+            if (DEV && is_jsonrpc_error_response(result)) {
+                const expected_code = http_status_to_jsonrpc_error_code(response.status);
+                const actual_code = result.error.code;
+                if (actual_code !== expected_code) {
+                    console.warn(`[http_transport] JSON-RPC error code mismatch: got ${actual_code} but ${response.status} should map to ${expected_code}`, result);
+                }
+            }
+            return result;
+        }
+        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 sending request', {
+                error: error.message || UNKNOWN_ERROR_MESSAGE,
+            }));
+        }
+    }
+    is_ready() {
+        return true;
+    }
+}

package/dist/actions/transports_ws.d.ts

@@ -0,0 +1,26 @@
+/**
+ * WebSocket transport — sends JSON-RPC messages via WebSocket with request tracking.
+ *
+ * @module
+ */
+import type { JsonrpcNotification, JsonrpcRequest, JsonrpcResponseOrError, JsonrpcErrorResponse } from '../http/jsonrpc.js';
+import type { Transport } from './transports.js';
+/**
+ * Minimal interface for a WebSocket connection, decoupled from the concrete Socket Cell.
+ */
+export interface WebsocketConnection {
+    send: (data: object) => boolean;
+    readonly connected: boolean;
+    add_message_handler: (handler: (event: MessageEvent) => void) => () => void;
+    add_error_handler: (handler: (event: Event) => void) => () => void;
+}
+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>;
+    is_ready(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=transports_ws.d.ts.map

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

@@ -0,0 +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;AAG5B,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"}