@iota-uz/sdk 0.4.44 → 0.5.1

package/dist/client-host/protocol.js

@@ -0,0 +1,2 @@
+// GENERATED — do not edit
+export const CLIENT_HOST_PROTOCOL_VERSION = "1.0.0";

package/dist/client-host/route.d.ts

@@ -0,0 +1,29 @@
+import type { ComponentType } from 'react';
+import { type WidgetSlotName } from './portals';
+export declare class ClientHostProtocolError extends Error {
+    readonly expected: string;
+    readonly actual: string;
+    constructor(expected: string, actual: string);
+}
+export interface ClientRouteContext<TInitial = unknown> {
+    protocolVersion: string;
+    sdkReleaseVersion: string;
+    sdkCommit: string;
+    initial: TInitial;
+    theme: 'light' | 'dark';
+    csrf?: string;
+}
+export interface MountClientRouteOptions<TInitial, TProps extends object> {
+    root: HTMLElement;
+    portals: HTMLElement;
+    background?: HTMLElement;
+    widgetSlots?: Partial<Record<WidgetSlotName, HTMLElement>>;
+    component: ComponentType<TProps & {
+        route: ClientRouteContext<TInitial>;
+    }>;
+    props: TProps;
+    context: ClientRouteContext<TInitial>;
+}
+export declare function assertClientHostProtocol(actual: string): void;
+export declare function mountClientRoute<TInitial, TProps extends object>(options: MountClientRouteOptions<TInitial, TProps>): () => void;
+//# sourceMappingURL=route.d.ts.map

package/dist/client-host/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../src/route.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C,OAAO,EAAsB,KAAK,cAAc,EAAE,MAAM,WAAW,CAAA;AAInE,qBAAa,uBAAwB,SAAQ,KAAK;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAAzC,QAAQ,EAAE,MAAM,EAAW,MAAM,EAAE,MAAM;CAI/D;AAED,MAAM,WAAW,kBAAkB,CAAC,QAAQ,GAAG,OAAO;IACpD,eAAe,EAAE,MAAM,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,QAAQ,CAAA;IACjB,KAAK,EAAE,OAAO,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,uBAAuB,CAAC,QAAQ,EAAE,MAAM,SAAS,MAAM;IACtE,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,EAAE,WAAW,CAAA;IACpB,UAAU,CAAC,EAAE,WAAW,CAAA;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAC,MAAM,GAAG;QAAE,KAAK,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAA;KAAE,CAAC,CAAA;IAC1E,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAA;CACtC;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAI7D;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,SAAS,MAAM,EAAE,OAAO,EAAE,uBAAuB,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,MAAM,IAAI,CAehI"}

package/dist/client-host/route.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createRoot } from 'react-dom/client';
+import { ClientHostProvider } from './portals';
+import { assertSDKIdentity } from './identity';
+import { CLIENT_HOST_PROTOCOL_VERSION } from './protocol';
+export class ClientHostProtocolError extends Error {
+    expected;
+    actual;
+    constructor(expected, actual) {
+        super(`Client host protocol ${actual} is incompatible with ${expected}`);
+        this.expected = expected;
+        this.actual = actual;
+        this.name = 'ClientHostProtocolError';
+    }
+}
+export function assertClientHostProtocol(actual) {
+    if (actual.split('.', 1)[0] !== CLIENT_HOST_PROTOCOL_VERSION.split('.', 1)[0]) {
+        throw new ClientHostProtocolError(CLIENT_HOST_PROTOCOL_VERSION, actual);
+    }
+}
+export function mountClientRoute(options) {
+    assertClientHostProtocol(options.context.protocolVersion);
+    assertSDKIdentity({
+        releaseVersion: options.context.sdkReleaseVersion,
+        sourceCommit: options.context.sdkCommit,
+        protocolVersion: options.context.protocolVersion,
+    });
+    const root = createRoot(options.root);
+    const Component = options.component;
+    root.render(_jsx(ClientHostProvider, { portalOwner: options.portals, background: options.background, widgetSlots: options.widgetSlots, theme: options.context.theme, children: _jsx(Component, { ...options.props, route: options.context }) }));
+    return () => root.unmount();
+}

package/dist/client-host/rpc.d.ts

@@ -0,0 +1,46 @@
+import { type QueryCache, type QueryKey } from './cache';
+import { HostError, type HostErrorHandlers } from './errors';
+export interface RPCMethodContract {
+    namespace: string;
+    method: string;
+    kind: 'query' | 'mutation';
+    cacheable?: boolean;
+    maxRetries?: number;
+    invalidates?: readonly string[];
+}
+export interface RPCTransport {
+    call<TRequest, TResponse>(method: string, request: TRequest, signal: AbortSignal): Promise<TResponse>;
+}
+export interface RPCDiagnostics {
+    call?(event: {
+        method: string;
+        key?: QueryKey;
+        state: 'start' | 'success' | 'error' | 'cancelled';
+        error?: HostError;
+    }): void;
+}
+export interface RPCClientOptions {
+    cache?: QueryCache;
+    errors?: HostErrorHandlers;
+    diagnostics?: RPCDiagnostics;
+}
+export declare class RPCClient {
+    readonly transport: RPCTransport;
+    readonly options: RPCClientOptions;
+    readonly cache: QueryCache;
+    constructor(transport: RPCTransport, options?: RPCClientOptions);
+    query<TRequest, TResponse>(contract: RPCMethodContract, request: TRequest, signal: AbortSignal): Promise<TResponse>;
+    mutate<TRequest, TResponse>(contract: RPCMethodContract, request: TRequest, signal: AbortSignal): Promise<TResponse>;
+}
+export type QueryState<T> = {
+    status: 'loading';
+} | {
+    status: 'success';
+    data: T;
+} | {
+    status: 'error';
+    error: HostError;
+};
+export declare function useRPCQuery<TRequest, TResponse>(client: RPCClient, contract: RPCMethodContract, request: TRequest): QueryState<TResponse>;
+export declare function useRPCMutation<TRequest, TResponse>(client: RPCClient, contract: RPCMethodContract): (request: TRequest) => Promise<TResponse>;
+//# sourceMappingURL=rpc.d.ts.map

package/dist/client-host/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../src/rpc.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAA;AACpF,OAAO,EAAkC,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5F,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,OAAO,GAAG,UAAU,CAAA;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAA;CACtG;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,SAAS,CAAA;KAAE,GAAG,IAAI,CAAA;CAC9H;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,WAAW,CAAC,EAAE,cAAc,CAAA;CAC7B;AAED,qBAAa,SAAS;IAER,QAAQ,CAAC,SAAS,EAAE,YAAY;IAAE,QAAQ,CAAC,OAAO,EAAE,gBAAgB;IADhF,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;gBACL,SAAS,EAAE,YAAY,EAAW,OAAO,GAAE,gBAAqB;IAI/E,KAAK,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IAgCnH,MAAM,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;CAe3H;AAED,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAAA;AAE1H,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,QAAQ,GAAG,UAAU,CAAC,SAAS,CAAC,CAezI;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,aAG7D,QAAQ,KAAG,OAAO,CAAC,SAAS,CAAC,CAKjE"}

package/dist/client-host/rpc.js

@@ -0,0 +1,90 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { MemoryQueryCache, queryKey } from './cache';
+import { asHostError, dispatchHostError, HostError } from './errors';
+export class RPCClient {
+    transport;
+    options;
+    cache;
+    constructor(transport, options = {}) {
+        this.transport = transport;
+        this.options = options;
+        this.cache = options.cache ?? new MemoryQueryCache();
+    }
+    async query(contract, request, signal) {
+        if (contract.kind !== 'query')
+            throw new HostError('protocol', `${contract.method} is not a query`);
+        const key = queryKey(contract.namespace, contract.method, request);
+        if (contract.cacheable !== false) {
+            const cached = this.cache.get(key);
+            if (cached !== undefined)
+                return cached;
+        }
+        let attempt = 0;
+        const maxRetries = Math.max(0, Math.min(3, contract.maxRetries ?? 2));
+        for (;;) {
+            this.options.diagnostics?.call?.({ method: contract.method, key, state: 'start' });
+            try {
+                const response = await this.transport.call(contract.method, request, signal);
+                if (contract.cacheable !== false)
+                    this.cache.set(key, response);
+                this.options.diagnostics?.call?.({ method: contract.method, key, state: 'success' });
+                return response;
+            }
+            catch (cause) {
+                if (signal.aborted) {
+                    this.options.diagnostics?.call?.({ method: contract.method, key, state: 'cancelled' });
+                    throw cause;
+                }
+                const error = asHostError(cause);
+                if (!error.retryable || attempt >= maxRetries) {
+                    dispatchHostError(error, this.options.errors);
+                    this.options.diagnostics?.call?.({ method: contract.method, key, state: 'error', error });
+                    throw error;
+                }
+                attempt += 1;
+            }
+        }
+    }
+    async mutate(contract, request, signal) {
+        if (contract.kind !== 'mutation')
+            throw new HostError('protocol', `${contract.method} is not a mutation`);
+        this.options.diagnostics?.call?.({ method: contract.method, state: 'start' });
+        try {
+            const response = await this.transport.call(contract.method, request, signal);
+            this.cache.invalidate(contract.namespace, contract.invalidates ?? []);
+            this.options.diagnostics?.call?.({ method: contract.method, state: 'success' });
+            return response;
+        }
+        catch (cause) {
+            const error = asHostError(cause);
+            if (!signal.aborted)
+                dispatchHostError(error, this.options.errors);
+            this.options.diagnostics?.call?.({ method: contract.method, state: signal.aborted ? 'cancelled' : 'error', error });
+            throw error;
+        }
+    }
+}
+export function useRPCQuery(client, contract, request) {
+    const [state, setState] = useState({ status: 'loading' });
+    const generation = useRef(0);
+    const requestKey = queryKey(contract.namespace, contract.method, request)[2];
+    useEffect(() => {
+        const current = ++generation.current;
+        const controller = new AbortController();
+        setState({ status: 'loading' });
+        void client.query(contract, request, controller.signal).then((data) => { if (generation.current === current)
+            setState({ status: 'success', data }); }, (cause) => { if (!controller.signal.aborted && generation.current === current)
+            setState({ status: 'error', error: asHostError(cause) }); });
+        return () => controller.abort();
+    }, [client, contract, requestKey]);
+    return state;
+}
+export function useRPCMutation(client, contract) {
+    const controller = useRef();
+    useEffect(() => () => controller.current?.abort(), []);
+    return useCallback(async (request) => {
+        controller.current?.abort();
+        controller.current = new AbortController();
+        return client.mutate(contract, request, controller.current.signal);
+    }, [client, contract]);
+}

package/dist/client-host/streaming.d.ts

@@ -0,0 +1,43 @@
+import { HostError, type HostErrorHandlers } from './errors';
+import type { QueryCache } from './cache';
+import { type SessionService } from './transport';
+export interface StreamContract<TEvent> {
+    id: string;
+    url: string;
+    method?: 'GET' | 'POST';
+    body?: BodyInit | (() => BodyInit);
+    headers?: Readonly<Record<string, string>>;
+    terminal(event: TEvent): boolean;
+    cursor?(event: TEvent): string | undefined;
+    invalidates?(event: TEvent): readonly {
+        namespace: string;
+        methods: readonly string[];
+    }[];
+}
+export interface StreamDiagnostics {
+    event?(event: {
+        stream: string;
+        state: 'connect' | 'event' | 'reconnect' | 'terminal' | 'error';
+        cursor?: string | undefined;
+        attempt?: number;
+        error?: HostError;
+    }): void;
+}
+export interface ManagedStreamOptions<TEvent> {
+    parse(data: string, event: string): TEvent;
+    session?: SessionService;
+    errors?: HostErrorHandlers;
+    diagnostics?: StreamDiagnostics;
+    cache?: QueryCache;
+    maxReconnects?: number;
+    staleAfterMs?: number;
+    baseDelayMs?: number;
+    fetch?: typeof globalThis.fetch;
+    random?: () => number;
+}
+export interface StreamSubscription {
+    close(): void;
+    readonly closed: boolean;
+}
+export declare function subscribeManagedStream<TEvent>(contract: StreamContract<TEvent>, onEvent: (event: TEvent) => void, options: ManagedStreamOptions<TEvent>): StreamSubscription;
+//# sourceMappingURL=streaming.d.ts.map

package/dist/client-host/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../src/streaming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,aAAa,CAAA;AAEjE,MAAM,WAAW,cAAc,CAAC,MAAM;IACpC,EAAE,EAAE,MAAM,CAAA;IACV,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,QAAQ,GAAG,CAAC,MAAM,QAAQ,CAAC,CAAA;IAClC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;IAChC,MAAM,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;IAC1C,WAAW,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,EAAE,CAAA;CAC1F;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,UAAU,GAAG,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,SAAS,CAAA;KAAE,GAAG,IAAI,CAAA;CAC3K;AAED,MAAM,WAAW,oBAAoB,CAAC,MAAM;IAC1C,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1C,OAAO,CAAC,EAAE,cAAc,CAAA;IACxB,MAAM,CAAC,EAAE,iBAAiB,CAAA;IAC1B,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B,KAAK,CAAC,EAAE,UAAU,CAAA;IAClB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,MAAM,CAAC,EAAE,MAAM,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,kBAAkB;IAAG,KAAK,IAAI,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE;AAI/E,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EAAE,OAAO,EAAE,oBAAoB,CAAC,MAAM,CAAC,GAAG,kBAAkB,CAuE5K"}

package/dist/client-host/streaming.js

@@ -0,0 +1,141 @@
+import { asHostError, dispatchHostError, HostError } from './errors';
+import { ManagedSession } from './transport';
+export function subscribeManagedStream(contract, onEvent, options) {
+    const controller = new AbortController();
+    let cursor;
+    let terminal = false;
+    let attempt = 0;
+    let refreshed = false;
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const maxReconnects = options.maxReconnects ?? 4;
+    const baseDelay = options.baseDelayMs ?? 250;
+    const run = async () => {
+        while (!controller.signal.aborted && !terminal) {
+            options.diagnostics?.event?.({ stream: contract.id, state: attempt === 0 ? 'connect' : 'reconnect', cursor, attempt });
+            try {
+                const sessionService = options.session ?? new ManagedSession({}, async () => ({}));
+                const session = sessionService.snapshot();
+                const body = typeof contract.body === 'function' ? contract.body() : contract.body;
+                const response = await fetcher(contract.url, {
+                    method: contract.method ?? 'GET',
+                    ...(body === undefined ? {} : { body }),
+                    credentials: 'same-origin', signal: controller.signal,
+                    headers: {
+                        accept: 'text/event-stream',
+                        ...(cursor ? { 'last-event-id': cursor } : {}),
+                        ...(session.csrf ? { 'x-csrf-token': session.csrf } : {}),
+                        ...session.headers,
+                        ...contract.headers,
+                    },
+                });
+                if (response.status === 401 && !refreshed) {
+                    await sessionService.refresh(controller.signal);
+                    refreshed = true;
+                    continue;
+                }
+                if (response.status === 401)
+                    throw new HostError('unauthenticated', 'Session expired');
+                if (response.status === 403)
+                    throw new HostError('permission_denied', 'Permission denied');
+                if (!response.ok || !response.body)
+                    throw new HostError(response.status >= 500 ? 'transient' : 'unknown', `Stream HTTP ${response.status}`);
+                for await (const message of readSSE(response.body, controller.signal, options.staleAfterMs ?? 45_000)) {
+                    if (message.id && message.id === cursor)
+                        continue;
+                    const event = options.parse(message.data, message.event);
+                    cursor = contract.cursor?.(event) ?? message.id ?? cursor;
+                    if (contract.terminal(event)) {
+                        if (terminal)
+                            continue;
+                        terminal = true;
+                        options.diagnostics?.event?.({ stream: contract.id, state: 'terminal', cursor });
+                    }
+                    else {
+                        options.diagnostics?.event?.({ stream: contract.id, state: 'event', cursor });
+                    }
+                    onEvent(event);
+                    for (const invalidation of contract.invalidates?.(event) ?? []) {
+                        options.cache?.invalidate(invalidation.namespace, invalidation.methods);
+                    }
+                    if (terminal)
+                        break;
+                }
+                if (!terminal)
+                    throw new HostError('transient', 'Stream ended before a terminal event');
+            }
+            catch (cause) {
+                if (controller.signal.aborted)
+                    return;
+                const error = asHostError(cause);
+                if (!error.retryable || attempt >= maxReconnects) {
+                    dispatchHostError(error, options.errors);
+                    options.diagnostics?.event?.({ stream: contract.id, state: 'error', cursor, error });
+                    return;
+                }
+                attempt += 1;
+                const jitter = 0.75 + (options.random?.() ?? Math.random()) * 0.5;
+                await abortableDelay(Math.min(8_000, baseDelay * 2 ** (attempt - 1)) * jitter, controller.signal);
+            }
+        }
+    };
+    void run();
+    return { close: () => controller.abort(), get closed() { return controller.signal.aborted; } };
+}
+async function* readSSE(stream, signal, staleAfterMs) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const result = await readWithTimeout(reader, staleAfterMs, signal);
+            if (result.done)
+                break;
+            buffer = (buffer + decoder.decode(result.value, { stream: true })).replaceAll('\r\n', '\n');
+            let boundary = buffer.indexOf('\n\n');
+            while (boundary >= 0) {
+                const block = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const message = parseSSEBlock(block);
+                if (message)
+                    yield message;
+                boundary = buffer.indexOf('\n\n');
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function readWithTimeout(reader, staleAfterMs, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new HostError('transient', 'Stream heartbeat timed out')), staleAfterMs);
+        const abort = () => { clearTimeout(timer); reject(signal.reason); };
+        signal.addEventListener('abort', abort, { once: true });
+        void reader.read().then((result) => { clearTimeout(timer); signal.removeEventListener('abort', abort); resolve(result); }, (error) => { clearTimeout(timer); signal.removeEventListener('abort', abort); reject(error); });
+    });
+}
+function parseSSEBlock(block) {
+    let id;
+    let event = 'message';
+    const data = [];
+    for (const line of block.replaceAll('\r', '').split('\n')) {
+        if (line.startsWith(':'))
+            continue;
+        const split = line.indexOf(':');
+        const field = split < 0 ? line : line.slice(0, split);
+        const value = split < 0 ? '' : line.slice(split + 1).replace(/^ /, '');
+        if (field === 'id')
+            id = value;
+        if (field === 'event')
+            event = value;
+        if (field === 'data')
+            data.push(value);
+    }
+    return data.length > 0 ? { ...(id === undefined ? {} : { id }), event, data: data.join('\n') } : undefined;
+}
+function abortableDelay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        signal.addEventListener('abort', () => { clearTimeout(timer); reject(signal.reason); }, { once: true });
+    });
+}

package/dist/client-host/transport.d.ts

@@ -0,0 +1,26 @@
+import type { RPCTransport } from './rpc';
+export interface SessionState {
+    csrf?: string;
+    headers?: Readonly<Record<string, string>>;
+}
+export interface SessionService {
+    snapshot(): SessionState;
+    refresh(signal: AbortSignal): Promise<SessionState>;
+}
+export declare class ManagedSession implements SessionService {
+    private readonly renew;
+    private state;
+    private refreshing;
+    constructor(initial: SessionState, renew: (signal: AbortSignal) => Promise<SessionState>);
+    snapshot(): SessionState;
+    refresh(signal: AbortSignal): Promise<SessionState>;
+}
+export declare class FetchRPCTransport implements RPCTransport {
+    readonly endpoint: string;
+    readonly session: SessionService;
+    private requestID;
+    constructor(endpoint: string, session?: SessionService);
+    call<TRequest, TResponse>(method: string, request: TRequest, signal: AbortSignal): Promise<TResponse>;
+    private request;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/client-host/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AAEzC,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAC3C;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,IAAI,YAAY,CAAA;IACxB,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;CACpD;AAED,qBAAa,cAAe,YAAW,cAAc;IAGhB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFzD,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,UAAU,CAAmC;gBACzC,OAAO,EAAE,YAAY,EAAmB,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,YAAY,CAAC;IACzG,QAAQ,IAAI,YAAY;IACxB,OAAO,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;CAIpD;AAED,qBAAa,iBAAkB,YAAW,YAAY;IAExC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAAE,QAAQ,CAAC,OAAO,EAAE,cAAc;IADvE,OAAO,CAAC,SAAS,CAAI;gBACA,QAAQ,EAAE,MAAM,EAAW,OAAO,GAAE,cAAyD;IAE5G,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;YAI7F,OAAO;CAsBtB"}

package/dist/client-host/transport.js

@@ -0,0 +1,53 @@
+import { asHostError, HostError } from './errors';
+export class ManagedSession {
+    renew;
+    state;
+    refreshing;
+    constructor(initial, renew) {
+        this.renew = renew;
+        this.state = initial;
+    }
+    snapshot() { return { ...this.state, headers: { ...this.state.headers } }; }
+    refresh(signal) {
+        this.refreshing ??= this.renew(signal).then((state) => { this.state = state; return this.snapshot(); }).finally(() => { this.refreshing = undefined; });
+        return this.refreshing;
+    }
+}
+export class FetchRPCTransport {
+    endpoint;
+    session;
+    requestID = 0;
+    constructor(endpoint, session = new ManagedSession({}, async () => ({}))) {
+        this.endpoint = endpoint;
+        this.session = session;
+    }
+    async call(method, request, signal) {
+        return this.request(method, request, signal, true);
+    }
+    async request(method, request, signal, mayRefresh) {
+        const session = this.session.snapshot();
+        const response = await fetch(this.endpoint, {
+            method: 'POST', credentials: 'same-origin', signal,
+            headers: {
+                'content-type': 'application/json',
+                ...(session.csrf ? { 'x-csrf-token': session.csrf } : {}),
+                ...session.headers,
+            },
+            body: JSON.stringify({ jsonrpc: '2.0', id: ++this.requestID, method, params: request }),
+        });
+        if (response.status === 401 && mayRefresh) {
+            await this.session.refresh(signal);
+            return this.request(method, request, signal, false);
+        }
+        if (response.status === 401)
+            throw new HostError('unauthenticated', 'Session expired');
+        if (response.status === 403)
+            throw new HostError('permission_denied', 'Permission denied');
+        if (!response.ok)
+            throw new HostError(response.status >= 500 ? 'transient' : 'unknown', `RPC HTTP ${response.status}`);
+        const payload = await response.json();
+        if (payload.error)
+            throw asHostError(payload.error);
+        return payload.result;
+    }
+}