@hyperdrive.bot/paseo-client 0.2.5

package/README.md

@@ -0,0 +1,12 @@
+# @hyperdrive.bot/paseo-client
+
+Paseo's JavaScript/TypeScript client package.
+
+## Stability
+
+This package is public so Paseo's published packages can depend on it cleanly.
+It is not a stable public SDK yet.
+
+APIs, exports, runtime behavior, and types may change or disappear in any
+release without advance notice. Use it outside Paseo at your own risk until the
+package is explicitly documented as stable.

package/dist/compat/normalize-provider-models.d.ts

@@ -0,0 +1,11 @@
+import type { GetProvidersSnapshotResponseMessage, ListProviderModelsResponseMessage, SessionOutboundMessage } from "@hyperdrive.bot/paseo-protocol/messages";
+type ListProviderModelsPayload = ListProviderModelsResponseMessage["payload"];
+type GetProvidersSnapshotPayload = GetProvidersSnapshotResponseMessage["payload"];
+type ProvidersSnapshotUpdatePayload = Extract<SessionOutboundMessage, {
+    type: "providers_snapshot_update";
+}>["payload"];
+export declare function normalizeListProviderModelsPayload(payload: ListProviderModelsPayload): ListProviderModelsPayload;
+export declare function normalizeProvidersSnapshotPayload<T extends GetProvidersSnapshotPayload | ProvidersSnapshotUpdatePayload>(payload: T): T;
+export declare function normalizeProviderSnapshotUpdateMessage(msg: SessionOutboundMessage): SessionOutboundMessage;
+export {};
+//# sourceMappingURL=normalize-provider-models.d.ts.map

package/dist/compat/normalize-provider-models.js

@@ -0,0 +1,42 @@
+import { normalizeAgentModelDefinition } from "@hyperdrive.bot/paseo-protocol/agent-types";
+// COMPAT(model-normalize): daemon normalizes at source (provider-registry) — shim covers older daemons; drop when floor >= v0.1.104
+function normalizeAgentModels(models) {
+    if (!models) {
+        return models;
+    }
+    let changed = false;
+    const normalized = models.map((model) => {
+        const next = normalizeAgentModelDefinition(model);
+        changed || (changed = next !== model);
+        return next;
+    });
+    return changed ? normalized : models;
+}
+function normalizeProviderSnapshotEntry(entry) {
+    const models = normalizeAgentModels(entry.models);
+    return models === entry.models ? entry : { ...entry, models };
+}
+function normalizeProviderSnapshotEntries(entries) {
+    let changed = false;
+    const normalized = entries.map((entry) => {
+        const next = normalizeProviderSnapshotEntry(entry);
+        changed || (changed = next !== entry);
+        return next;
+    });
+    return changed ? normalized : entries;
+}
+export function normalizeListProviderModelsPayload(payload) {
+    const models = normalizeAgentModels(payload.models);
+    return models === payload.models ? payload : { ...payload, models };
+}
+export function normalizeProvidersSnapshotPayload(payload) {
+    const entries = normalizeProviderSnapshotEntries(payload.entries);
+    return entries === payload.entries ? payload : { ...payload, entries };
+}
+export function normalizeProviderSnapshotUpdateMessage(msg) {
+    if (msg.type !== "providers_snapshot_update") {
+        return msg;
+    }
+    return { ...msg, payload: normalizeProvidersSnapshotPayload(msg.payload) };
+}
+//# sourceMappingURL=normalize-provider-models.js.map

package/dist/daemon-client-relay-e2ee-transport.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonTransport, DaemonTransportFactory, TransportLogger } from "./daemon-client-transport-types.js";
+export declare function createRelayE2eeTransportFactory(args: {
+    baseFactory: DaemonTransportFactory;
+    daemonPublicKeyB64: string;
+    logger: TransportLogger;
+}): DaemonTransportFactory;
+export declare function createEncryptedTransport(base: DaemonTransport, daemonPublicKeyB64: string, logger: TransportLogger): DaemonTransport;
+//# sourceMappingURL=daemon-client-relay-e2ee-transport.d.ts.map

package/dist/daemon-client-relay-e2ee-transport.js

@@ -0,0 +1,161 @@
+import { createClientChannel, } from "@hyperdrive.bot/paseo-relay/e2ee";
+import { extractRelayMessageData, normalizeTransportPayload, } from "./daemon-client-transport-utils.js";
+export function createRelayE2eeTransportFactory(args) {
+    return ({ url, headers }) => {
+        const base = args.baseFactory({ url, headers });
+        return createEncryptedTransport(base, args.daemonPublicKeyB64, args.logger);
+    };
+}
+export function createEncryptedTransport(base, daemonPublicKeyB64, logger) {
+    let channel = null;
+    let opened = false;
+    let closed = false;
+    const openHandlers = new Set();
+    const closeHandlers = new Set();
+    const errorHandlers = new Set();
+    const messageHandlers = new Set();
+    const emitOpen = () => {
+        if (opened || closed) {
+            return;
+        }
+        opened = true;
+        emitHandlers(openHandlers);
+    };
+    const emitClose = (event) => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        emitHandlers(closeHandlers, event);
+    };
+    const emitError = (event) => {
+        if (closed) {
+            return;
+        }
+        emitHandlers(errorHandlers, event);
+    };
+    const emitMessage = (data) => {
+        if (closed) {
+            return;
+        }
+        emitHandlers(messageHandlers, data);
+    };
+    const relayTransport = {
+        send: (data) => {
+            if (typeof data === "string") {
+                base.send(data);
+                return;
+            }
+            if (ArrayBuffer.isView(data)) {
+                base.send(normalizeTransportPayload(data));
+                return;
+            }
+            if (data instanceof ArrayBuffer) {
+                base.send(data);
+                return;
+            }
+            base.send(String(data));
+        },
+        close: (code, reason) => base.close(code, reason),
+        onmessage: null,
+        onclose: null,
+        onerror: null,
+    };
+    const startHandshake = async () => {
+        try {
+            channel = await createClientChannel(relayTransport, daemonPublicKeyB64, {
+                onopen: emitOpen,
+                onmessage: (data) => emitMessage(data),
+                onclose: (code, reason) => emitClose({ code, reason }),
+                onerror: (error) => emitError(error),
+            });
+        }
+        catch (error) {
+            logger.warn({ err: normalizeTransportError(error) }, "relay_e2ee_handshake_failed");
+            emitError(error);
+            // Browser WebSocket.close only accepts 1000 or 3000-4999.
+            // Use an app-defined code so this path works in browser and Node runtimes.
+            base.close(4001, "E2EE handshake failed");
+        }
+    };
+    base.onOpen(() => {
+        void startHandshake();
+    });
+    base.onMessage((event) => {
+        relayTransport.onmessage?.(extractRelayMessageData(event));
+    });
+    base.onClose((event) => {
+        const record = event;
+        relayTransport.onclose?.(record?.code ?? 0, record?.reason ?? "");
+        emitClose(event);
+    });
+    base.onError((event) => {
+        relayTransport.onerror?.(event instanceof Error ? event : new Error(String(event)));
+        emitError(event);
+    });
+    return {
+        send: (data) => {
+            if (!channel) {
+                throw new Error("Encrypted channel not ready");
+            }
+            void channel.send(normalizeTransportPayload(data)).catch((error) => {
+                emitError(error);
+            });
+        },
+        close: (code, reason) => {
+            if (channel) {
+                channel.close(code, reason);
+            }
+            else {
+                base.close(code, reason);
+            }
+            emitClose({ code, reason });
+        },
+        onMessage: (handler) => {
+            messageHandlers.add(handler);
+            return () => messageHandlers.delete(handler);
+        },
+        onOpen: (handler) => {
+            openHandlers.add(handler);
+            if (opened) {
+                invokeHandler(handler);
+            }
+            return () => openHandlers.delete(handler);
+        },
+        onClose: (handler) => {
+            closeHandlers.add(handler);
+            if (closed) {
+                invokeHandler(handler);
+            }
+            return () => closeHandlers.delete(handler);
+        },
+        onError: (handler) => {
+            errorHandlers.add(handler);
+            return () => errorHandlers.delete(handler);
+        },
+    };
+}
+function emitHandlers(handlers, ...args) {
+    for (const handler of handlers) {
+        invokeHandler(handler, ...args);
+    }
+}
+function invokeHandler(handler, ...args) {
+    try {
+        handler(...args);
+    }
+    catch {
+        // no-op
+    }
+}
+function normalizeTransportError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            ...(typeof error.stack === "string" ? { stack: error.stack } : {}),
+        };
+    }
+    return { message: String(error) };
+}
+//# sourceMappingURL=daemon-client-relay-e2ee-transport.js.map

package/dist/daemon-client-runtime-metrics.d.ts

@@ -0,0 +1,39 @@
+import type { SessionOutboundMessage } from "@hyperdrive.bot/paseo-protocol/messages";
+interface RuntimeMetricsLogger {
+    info(obj: object, msg?: string): void;
+}
+interface RuntimeMetricsContext {
+    connectionPath: "direct" | "relay";
+    serverId: string | null;
+    getConnectionStatus: () => string;
+}
+interface RuntimeMetricsOptions {
+    windowMs?: number;
+}
+export declare class DaemonClientRuntimeMetrics {
+    private readonly logger;
+    private readonly context;
+    private readonly startedAt;
+    private readonly windowMs;
+    private readonly buckets;
+    private readonly inboundMessageCounts;
+    private readonly inboundMessageBytes;
+    private readonly inboundMessageHandlerMs;
+    private readonly inboundAgentStreamCounts;
+    private readonly inboundAgentStreamByAgentCounts;
+    private readonly inboundBinaryFrameCounts;
+    constructor(logger: RuntimeMetricsLogger, context: RuntimeMetricsContext, options?: RuntimeMetricsOptions);
+    recordMessage(type: string, bytes: number, handlerMs: number): void;
+    recordAgentStream(payload: Extract<SessionOutboundMessage, {
+        type: "agent_stream";
+    }>["payload"]): void;
+    recordBinaryFrame(kind: string, bytes: number, handlerMs: number): void;
+    flush(options?: {
+        final?: boolean;
+    }): void;
+    private consumeCurrentBucket;
+    private pruneBuckets;
+    private aggregateBuckets;
+}
+export {};
+//# sourceMappingURL=daemon-client-runtime-metrics.d.ts.map

package/dist/daemon-client-runtime-metrics.js

@@ -0,0 +1,173 @@
+const DEFAULT_ROLLING_WINDOW_MS = 60000;
+export class DaemonClientRuntimeMetrics {
+    constructor(logger, context, options) {
+        this.logger = logger;
+        this.context = context;
+        this.startedAt = Date.now();
+        this.buckets = [];
+        this.inboundMessageCounts = new Map();
+        this.inboundMessageBytes = new Map();
+        this.inboundMessageHandlerMs = new Map();
+        this.inboundAgentStreamCounts = new Map();
+        this.inboundAgentStreamByAgentCounts = new Map();
+        this.inboundBinaryFrameCounts = new Map();
+        this.windowMs =
+            typeof options?.windowMs === "number" && options.windowMs > 0
+                ? options.windowMs
+                : DEFAULT_ROLLING_WINDOW_MS;
+    }
+    recordMessage(type, bytes, handlerMs) {
+        incrementCount(this.inboundMessageCounts, type, 1);
+        incrementCount(this.inboundMessageBytes, type, bytes);
+        incrementHandlerTiming(this.inboundMessageHandlerMs, type, handlerMs);
+    }
+    recordAgentStream(payload) {
+        const { agentId, event } = payload;
+        const eventType = event.type === "timeline" ? `timeline:${event.item.type}` : event.type;
+        incrementCount(this.inboundAgentStreamCounts, eventType, 1);
+        incrementCount(this.inboundAgentStreamByAgentCounts, agentId, 1);
+    }
+    recordBinaryFrame(kind, bytes, handlerMs) {
+        incrementCount(this.inboundBinaryFrameCounts, kind, 1);
+        incrementCount(this.inboundMessageBytes, `binary:${kind}`, bytes);
+        incrementHandlerTiming(this.inboundMessageHandlerMs, `binary:${kind}`, handlerMs);
+    }
+    flush(options) {
+        const now = Date.now();
+        const bucket = this.consumeCurrentBucket(now);
+        if (bucket) {
+            this.buckets.push(bucket);
+        }
+        this.pruneBuckets(now);
+        const aggregate = this.aggregateBuckets();
+        const hasActivity = aggregate.inboundMessageCounts.size > 0 || aggregate.inboundBinaryFrameCounts.size > 0;
+        if (!hasActivity && !options?.final) {
+            return;
+        }
+        this.logger.info({
+            windowMs: Math.min(this.windowMs, Math.max(0, now - this.startedAt)),
+            rollingWindowMs: this.windowMs,
+            bucketCount: this.buckets.length,
+            final: Boolean(options?.final),
+            connectionPath: this.context.connectionPath,
+            serverId: this.context.serverId,
+            connectionStatus: this.context.getConnectionStatus(),
+            inboundMessageTypesTop: getTopCounts(aggregate.inboundMessageCounts, 20),
+            inboundMessageBytesTop: getTopCounts(aggregate.inboundMessageBytes, 20),
+            inboundAgentStreamTypesTop: getTopCounts(aggregate.inboundAgentStreamCounts, 20),
+            inboundAgentStreamAgentsTop: getTopCounts(aggregate.inboundAgentStreamByAgentCounts, 20),
+            inboundBinaryFrameTypesTop: getTopCounts(aggregate.inboundBinaryFrameCounts, 12),
+            handlerTimingTop: getTopHandlerTimings(aggregate.inboundMessageHandlerMs, 20),
+        }, "ws_runtime_metrics_client");
+    }
+    consumeCurrentBucket(now) {
+        const hasActivity = this.inboundMessageCounts.size > 0 || this.inboundBinaryFrameCounts.size > 0;
+        if (!hasActivity) {
+            return null;
+        }
+        const bucket = {
+            inboundMessageCounts: new Map(this.inboundMessageCounts),
+            inboundMessageBytes: new Map(this.inboundMessageBytes),
+            inboundMessageHandlerMs: cloneHandlerTimingMap(this.inboundMessageHandlerMs),
+            inboundAgentStreamCounts: new Map(this.inboundAgentStreamCounts),
+            inboundAgentStreamByAgentCounts: new Map(this.inboundAgentStreamByAgentCounts),
+            inboundBinaryFrameCounts: new Map(this.inboundBinaryFrameCounts),
+            endedAt: now,
+        };
+        this.inboundMessageCounts.clear();
+        this.inboundMessageBytes.clear();
+        this.inboundMessageHandlerMs.clear();
+        this.inboundAgentStreamCounts.clear();
+        this.inboundAgentStreamByAgentCounts.clear();
+        this.inboundBinaryFrameCounts.clear();
+        return bucket;
+    }
+    pruneBuckets(now) {
+        const cutoff = now - this.windowMs;
+        while (this.buckets.length > 0 && this.buckets[0].endedAt < cutoff) {
+            this.buckets.shift();
+        }
+    }
+    aggregateBuckets() {
+        const aggregate = createEmptyBucket(Date.now());
+        for (const bucket of this.buckets) {
+            mergeCountMap(aggregate.inboundMessageCounts, bucket.inboundMessageCounts);
+            mergeCountMap(aggregate.inboundMessageBytes, bucket.inboundMessageBytes);
+            mergeHandlerTimingMap(aggregate.inboundMessageHandlerMs, bucket.inboundMessageHandlerMs);
+            mergeCountMap(aggregate.inboundAgentStreamCounts, bucket.inboundAgentStreamCounts);
+            mergeCountMap(aggregate.inboundAgentStreamByAgentCounts, bucket.inboundAgentStreamByAgentCounts);
+            mergeCountMap(aggregate.inboundBinaryFrameCounts, bucket.inboundBinaryFrameCounts);
+        }
+        return aggregate;
+    }
+}
+function createEmptyBucket(endedAt) {
+    return {
+        inboundMessageCounts: new Map(),
+        inboundMessageBytes: new Map(),
+        inboundMessageHandlerMs: new Map(),
+        inboundAgentStreamCounts: new Map(),
+        inboundAgentStreamByAgentCounts: new Map(),
+        inboundBinaryFrameCounts: new Map(),
+        endedAt,
+    };
+}
+function incrementCount(map, key, amount) {
+    map.set(key, (map.get(key) ?? 0) + amount);
+}
+function incrementHandlerTiming(map, key, handlerMs) {
+    const existing = map.get(key);
+    if (existing) {
+        existing.count += 1;
+        existing.totalMs += handlerMs;
+        existing.maxMs = Math.max(existing.maxMs, handlerMs);
+        return;
+    }
+    map.set(key, {
+        count: 1,
+        totalMs: handlerMs,
+        maxMs: handlerMs,
+    });
+}
+function cloneHandlerTimingMap(map) {
+    return new Map([...map.entries()].map(([key, value]) => [
+        key,
+        { count: value.count, totalMs: value.totalMs, maxMs: value.maxMs },
+    ]));
+}
+function mergeCountMap(target, source) {
+    for (const [key, value] of source) {
+        incrementCount(target, key, value);
+    }
+}
+function mergeHandlerTimingMap(target, source) {
+    for (const [key, value] of source) {
+        const existing = target.get(key);
+        if (existing) {
+            existing.count += value.count;
+            existing.totalMs += value.totalMs;
+            existing.maxMs = Math.max(existing.maxMs, value.maxMs);
+            continue;
+        }
+        target.set(key, {
+            count: value.count,
+            totalMs: value.totalMs,
+            maxMs: value.maxMs,
+        });
+    }
+}
+function getTopCounts(map, limit) {
+    return [...map.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
+}
+function getTopHandlerTimings(map, limit) {
+    const rows = [...map.entries()].map(([type, value]) => ({
+        type,
+        count: value.count,
+        totalMs: Math.round(value.totalMs),
+        avgMs: Math.round((value.totalMs / value.count) * 100) / 100,
+        maxMs: Math.round(value.maxMs * 100) / 100,
+    }));
+    rows.sort((a, b) => b.totalMs - a.totalMs);
+    return rows.slice(0, limit);
+}
+//# sourceMappingURL=daemon-client-runtime-metrics.js.map

package/dist/daemon-client-transport-types.d.ts

@@ -0,0 +1,36 @@
+export interface DaemonTransport {
+    send: (data: string | Uint8Array | ArrayBuffer) => void;
+    close: (code?: number, reason?: string) => void;
+    onMessage: (handler: (data: unknown) => void) => () => void;
+    onOpen: (handler: () => void) => () => void;
+    onClose: (handler: (event?: unknown) => void) => () => void;
+    onError: (handler: (event?: unknown) => void) => () => void;
+}
+export type DaemonTransportFactory = (options: {
+    url: string;
+    headers?: Record<string, string>;
+    protocols?: string[];
+}) => DaemonTransport;
+export type WebSocketFactory = (url: string, options?: {
+    headers?: Record<string, string>;
+    protocols?: string[];
+}) => WebSocketLike;
+export interface WebSocketLike {
+    readyState: number;
+    send: (data: string | Uint8Array | ArrayBuffer) => void;
+    close: (code?: number, reason?: string) => void;
+    binaryType?: string;
+    on?: (event: string, listener: (...args: unknown[]) => void) => void;
+    off?: (event: string, listener: (...args: unknown[]) => void) => void;
+    removeListener?: (event: string, listener: (...args: unknown[]) => void) => void;
+    addEventListener?: (event: string, listener: (event: unknown) => void) => void;
+    removeEventListener?: (event: string, listener: (event: unknown) => void) => void;
+    onopen?: ((event: unknown) => void) | null;
+    onclose?: ((event: unknown) => void) | null;
+    onerror?: ((event: unknown) => void) | null;
+    onmessage?: ((event: unknown) => void) | null;
+}
+export interface TransportLogger {
+    warn(obj: object, msg?: string): void;
+}
+//# sourceMappingURL=daemon-client-transport-types.d.ts.map

package/dist/daemon-client-transport-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=daemon-client-transport-types.js.map

package/dist/daemon-client-transport-utils.d.ts

@@ -0,0 +1,9 @@
+export declare function copyArrayBufferViewToBuffer(data: ArrayBufferView): ArrayBuffer;
+export declare function normalizeTransportPayload(data: string | Uint8Array | ArrayBuffer): string | ArrayBuffer;
+export declare function extractRelayMessageData(event: unknown): string | ArrayBuffer;
+export declare function describeTransportClose(event?: unknown): string;
+export declare function describeTransportError(event?: unknown): string;
+export declare function safeRandomId(): string;
+export declare function decodeMessageData(data: unknown): string | null;
+export declare function encodeUtf8String(value: string): Uint8Array;
+//# sourceMappingURL=daemon-client-transport-utils.d.ts.map

package/dist/daemon-client-transport-utils.js

@@ -0,0 +1,121 @@
+export function copyArrayBufferViewToBuffer(data) {
+    const view = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    const out = new Uint8Array(view.byteLength);
+    out.set(view);
+    return out.buffer;
+}
+export function normalizeTransportPayload(data) {
+    if (typeof data === "string" || data instanceof ArrayBuffer) {
+        return data;
+    }
+    return copyArrayBufferViewToBuffer(data);
+}
+export function extractRelayMessageData(event) {
+    const raw = event && typeof event === "object" && "data" in event
+        ? event.data
+        : event;
+    if (typeof raw === "string")
+        return raw;
+    if (raw instanceof ArrayBuffer)
+        return raw;
+    if (ArrayBuffer.isView(raw)) {
+        return copyArrayBufferViewToBuffer(raw);
+    }
+    return String(raw ?? "");
+}
+export function describeTransportClose(event) {
+    if (!event) {
+        return "Transport closed";
+    }
+    if (event instanceof Error) {
+        return event.message;
+    }
+    if (typeof event === "string") {
+        return event;
+    }
+    if (typeof event === "object") {
+        const record = event;
+        if (typeof record.reason === "string" && record.reason.trim().length > 0) {
+            return record.reason.trim();
+        }
+        if (typeof record.message === "string" && record.message.trim().length > 0) {
+            return record.message.trim();
+        }
+        if (typeof record.code === "number") {
+            return `Transport closed (code ${record.code})`;
+        }
+    }
+    return "Transport closed";
+}
+export function describeTransportError(event) {
+    if (!event) {
+        return "Transport error";
+    }
+    if (event instanceof Error) {
+        return event.message;
+    }
+    if (typeof event === "string") {
+        return event;
+    }
+    if (typeof event === "object") {
+        const record = event;
+        if (typeof record.message === "string" && record.message.trim().length > 0) {
+            return record.message.trim();
+        }
+    }
+    return "Transport error";
+}
+export function safeRandomId() {
+    try {
+        if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+            return crypto.randomUUID();
+        }
+    }
+    catch {
+        // ignore
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+export function decodeMessageData(data) {
+    if (data === null || data === undefined) {
+        return null;
+    }
+    if (typeof data === "string") {
+        return data;
+    }
+    if (typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) {
+        if (typeof Buffer !== "undefined") {
+            return Buffer.from(data).toString("utf8");
+        }
+        if (typeof TextDecoder !== "undefined") {
+            return new TextDecoder().decode(data);
+        }
+    }
+    if (ArrayBuffer.isView(data)) {
+        const view = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        if (typeof Buffer !== "undefined") {
+            return Buffer.from(view).toString("utf8");
+        }
+        if (typeof TextDecoder !== "undefined") {
+            return new TextDecoder().decode(view);
+        }
+    }
+    if (typeof data.toString === "function") {
+        return data.toString();
+    }
+    return null;
+}
+export function encodeUtf8String(value) {
+    if (typeof TextEncoder !== "undefined") {
+        return new TextEncoder().encode(value);
+    }
+    if (typeof Buffer !== "undefined") {
+        return new Uint8Array(Buffer.from(value, "utf8"));
+    }
+    const out = new Uint8Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+        out[i] = value.charCodeAt(i) & 0xff;
+    }
+    return out;
+}
+//# sourceMappingURL=daemon-client-transport-utils.js.map

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

@@ -0,0 +1,5 @@
+export type { DaemonTransport, DaemonTransportFactory, TransportLogger, WebSocketFactory, WebSocketLike, } from "./daemon-client-transport-types.js";
+export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessageData, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
+export { createEncryptedTransport, createRelayE2eeTransportFactory, } from "./daemon-client-relay-e2ee-transport.js";
+export { bindWsHandler, createWebSocketTransportFactory, defaultWebSocketFactory, } from "./daemon-client-websocket-transport.js";
+//# sourceMappingURL=daemon-client-transport.d.ts.map

package/dist/daemon-client-transport.js

@@ -0,0 +1,4 @@
+export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessageData, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
+export { createEncryptedTransport, createRelayE2eeTransportFactory, } from "./daemon-client-relay-e2ee-transport.js";
+export { bindWsHandler, createWebSocketTransportFactory, defaultWebSocketFactory, } from "./daemon-client-websocket-transport.js";
+//# sourceMappingURL=daemon-client-transport.js.map

package/dist/daemon-client-websocket-transport.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonTransportFactory, WebSocketFactory, WebSocketLike } from "./daemon-client-transport-types.js";
+export declare function defaultWebSocketFactory(url: string, options?: {
+    headers?: Record<string, string>;
+    protocols?: string[];
+}): WebSocketLike;
+export declare function createWebSocketTransportFactory(factory: WebSocketFactory): DaemonTransportFactory;
+export declare function bindWsHandler(ws: WebSocketLike, event: "open" | "close" | "error" | "message", handler: (...args: unknown[]) => void): () => void;
+//# sourceMappingURL=daemon-client-websocket-transport.d.ts.map