@bian-womp/spark-remote 0.2.37 → 0.2.39

package/lib/cjs/index.cjs

@@ -1,756 +1,17 @@
 'use strict';
 
-var ws = require('ws');
-var sparkGraph = require('@bian-womp/spark-graph');
+var index = require('./index-BKs-fgHN.js');
+require('ws');
+require('@bian-womp/spark-graph');
 
-class SeqGenerator {
-    constructor() {
-        this.lastMs = 0;
-        this.seqInMs = 0;
-    }
-    next() {
-        const now = Date.now();
-        if (now === this.lastMs) {
-            this.seqInMs = (this.seqInMs + 1) % 1000;
-        }
-        else {
-            this.lastMs = now;
-            this.seqInMs = 0;
-        }
-        return now * 1000 + this.seqInMs;
-    }
-}
 
-const OPEN = 1;
-class WebSocketTransport {
-    constructor(url) {
-        this.listeners = new Set();
-        this.seq = new SeqGenerator();
-        this.baseUrl = url;
-    }
-    async connect(options) {
-        if (this.ws && this.ws.readyState === OPEN)
-            return;
-        // Build URL with connection params
-        // Handle both ws:///wss:// URLs and http:///https:// URLs (convert to ws)
-        let url;
-        if (this.baseUrl.startsWith("ws://") || this.baseUrl.startsWith("wss://")) {
-            url = new URL(this.baseUrl);
-        }
-        else {
-            // Convert http/https to ws/wss
-            const wsBaseUrl = this.baseUrl.replace(/^http/, "ws");
-            url = new URL(wsBaseUrl);
-        }
-        if (options?.params) {
-            for (const [key, value] of Object.entries(options.params)) {
-                if (value !== undefined && value !== null) {
-                    url.searchParams.set(key, String(value));
-                }
-            }
-        }
-        const wsUrl = url.toString();
-        this.ws = window
-            ? new window.WebSocket(wsUrl)
-            : new ws.WebSocket(wsUrl);
-        await new Promise((resolve, reject) => {
-            if (!this.ws)
-                return reject(new Error("ws init failed"));
-            this.ws.onopen = () => resolve();
-            this.ws.onerror = (e) => reject(e);
-            this.ws.onmessage = (ev) => {
-                try {
-                    const env = JSON.parse(String(ev.data));
-                    for (const l of Array.from(this.listeners))
-                        l(env);
-                }
-                catch { }
-            };
-        });
-    }
-    async request(msg) {
-        // For now, just send and wait for the next message with matching seq (simple demo)
-        const seq = this.seq.next();
-        const env = { ...msg, seq };
-        const p = new Promise((resolve) => {
-            const off = this.subscribe((incoming) => {
-                if (incoming.seq === seq) {
-                    off();
-                    resolve(incoming);
-                }
-            });
-        });
-        this.send(env);
-        return p;
-    }
-    send(msg) {
-        if (!this.ws || this.ws.readyState !== OPEN)
-            return;
-        this.ws.send(JSON.stringify(msg));
-    }
-    subscribe(cb) {
-        this.listeners.add(cb);
-        return () => this.listeners.delete(cb);
-    }
-    async close() {
-        if (!this.ws)
-            return;
-        const ws = this.ws;
-        this.ws = undefined;
-        await new Promise((resolve) => {
-            ws.onclose = () => resolve();
-            try {
-                ws.close();
-            }
-            catch {
-                resolve();
-            }
-        });
-    }
-}
 
-class HttpPollingTransport {
-    constructor(baseUrl) {
-        this.listeners = new Set();
-        this.baseUrl = baseUrl.replace(/\/$/, "");
-    }
-    async connect(options) {
-        // Store connection params for use in requests
-        this.connectParams = options?.params;
-        // Start polling loop
-        if (this.polling)
-            return;
-        const tick = async () => {
-            try {
-                const url = new URL(this.baseUrl + "/events");
-                if (this.cursor)
-                    url.searchParams.set("cursor", this.cursor);
-                // Add connection params to all requests
-                if (this.connectParams) {
-                    for (const [key, value] of Object.entries(this.connectParams)) {
-                        if (value !== undefined && value !== null) {
-                            url.searchParams.set(key, String(value));
-                        }
-                    }
-                }
-                const res = await fetch(url.toString());
-                if (!res.ok)
-                    return;
-                const batch = (await res.json());
-                for (const env of batch) {
-                    this.cursor = String(env.seq ?? Date.now());
-                    for (const l of Array.from(this.listeners))
-                        l(env);
-                }
-            }
-            catch { }
-        };
-        this.polling = setInterval(tick, 200);
-    }
-    async request(msg) {
-        const url = new URL(this.baseUrl + "/command");
-        // Add connection params to command requests
-        if (this.connectParams) {
-            for (const [key, value] of Object.entries(this.connectParams)) {
-                if (value !== undefined && value !== null) {
-                    url.searchParams.set(key, String(value));
-                }
-            }
-        }
-        const res = await fetch(url.toString(), {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(msg),
-        });
-        const data = (await res.json());
-        return data;
-    }
-    send(msg) {
-        const url = new URL(this.baseUrl + "/command");
-        // Add connection params to send requests
-        if (this.connectParams) {
-            for (const [key, value] of Object.entries(this.connectParams)) {
-                if (value !== undefined && value !== null) {
-                    url.searchParams.set(key, String(value));
-                }
-            }
-        }
-        fetch(url.toString(), {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify(msg),
-        });
-    }
-    subscribe(cb) {
-        this.listeners.add(cb);
-        return () => this.listeners.delete(cb);
-    }
-    async close() {
-        if (this.polling)
-            clearInterval(this.polling);
-        this.polling = undefined;
-    }
-}
-
-class RemoteEngine {
-    constructor(transport) {
-        this.transport = transport;
-        this.listeners = new Map();
-        this.cache = new Map();
-        this.transport.subscribe((env) => this.onEnvelope(env));
-    }
-    onEnvelope(env) {
-        const msg = env.message;
-        if (!msg)
-            return;
-        if (msg.type === "value") {
-            const key = `${msg.payload.nodeId}.${msg.payload.handle}`;
-            this.cache.set(key, {
-                value: msg.payload.value,
-                runtimeTypeId: msg.payload.runtimeTypeId,
-            });
-            this.emit("value", msg.payload);
-        }
-        else if (msg.type === "error") {
-            this.emit("error", msg.payload);
-        }
-        else if (msg.type === "invalidate") {
-            this.emit("invalidate", msg.payload);
-        }
-        else if (msg.type === "stats") {
-            this.emit("stats", msg.payload);
-        }
-    }
-    launch(invalidate) {
-        this.transport.send({
-            message: { type: "Launch", payload: { invalidate } },
-        });
-    }
-    setInput(nodeId, handle, value) {
-        this.transport.send({
-            message: { type: "SetInput", payload: { nodeId, handle, value } },
-        });
-    }
-    // Batch inputs for a single network round-trip
-    setInputs(nodeId, inputs) {
-        this.transport.send({
-            message: { type: "SetInputs", payload: { nodeId, inputs } },
-        });
-    }
-    triggerExternal(nodeId, event) {
-        this.transport.send({
-            message: { type: "TriggerExternal", payload: { nodeId, event } },
-        });
-    }
-    on(event, handler) {
-        if (!this.listeners.has(event))
-            this.listeners.set(event, new Set());
-        const set = this.listeners.get(event);
-        set.add(handler);
-        return () => set.delete(handler);
-    }
-    emit(event, payload) {
-        const set = this.listeners.get(event);
-        if (set)
-            for (const h of Array.from(set))
-                h(payload);
-    }
-    getOutput(nodeId, output) {
-        return this.cache.get(`${nodeId}.${output}`)?.value;
-    }
-    async whenIdle() {
-        await this.transport.request({ message: { type: "WhenIdle" } });
-    }
-    dispose() {
-        this.transport.send({ message: { type: "Dispose" } });
-    }
-}
-
-class RemoteRunner {
-    constructor(transport) {
-        this.transport = transport;
-        this.engine = new RemoteEngine(transport);
-    }
-    async build(def, opts) {
-        await this.transport.request({
-            message: {
-                type: "Build",
-                payload: { def, environment: opts?.environment },
-            },
-        });
-    }
-    async update(def) {
-        await this.transport.request({
-            message: { type: "Update", payload: { def } },
-        });
-    }
-    async describeRegistry() {
-        const res = await this.transport.request({
-            message: { type: "DescribeRegistry" },
-        });
-        const payload = res?.message || {};
-        return (payload.registry || {
-            types: [],
-            categories: [],
-            nodes: [],
-            coercions: [],
-            schemaVersion: 4,
-        });
-    }
-    async applyRegistry(deltas) {
-        await this.transport.request({
-            message: { type: "RegistryApply", payload: { deltas } },
-        });
-    }
-    async snapshot() {
-        const res = await this.transport.request({ message: { type: "Snapshot" } });
-        const payload = res?.message || {};
-        return payload.snapshot || { inputs: {}, outputs: {} };
-    }
-    async snapshotFull() {
-        const res = await this.transport.request({
-            message: { type: "SnapshotFull" },
-        });
-        const payload = res?.message || {};
-        return (payload.snapshot || {
-            def: undefined,
-            environment: {},
-            inputs: {},
-            outputs: {},
-        });
-    }
-    async applySnapshotFull(payload) {
-        await this.transport.request({
-            message: { type: "ApplySnapshotFull", payload },
-        });
-    }
-    async setEnvironment(environment, opts) {
-        await this.transport.request({
-            message: {
-                type: "SetEnvironment",
-                payload: { environment, merge: opts?.merge },
-            },
-        });
-    }
-    async getEnvironment() {
-        const res = await this.transport.request({
-            message: { type: "GetEnvironment" },
-        });
-        const payload = res?.message || {};
-        return payload.environment || {};
-    }
-    async coerce(from, to, value) {
-        const res = await this.transport.request({
-            message: { type: "Coerce", payload: { from, to, value } },
-        });
-        const payload = res?.message || {};
-        return payload.value;
-    }
-    getEngine() {
-        return this.engine;
-    }
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-function summarize(value, maxLen = 120) {
-    try {
-        const s = typeof value === "string" ? value : JSON.stringify(value);
-        return s.length > maxLen ? s.slice(0, maxLen) + "…" : s;
-    }
-    catch {
-        return String(value);
-    }
-}
-function serializeError(err) {
-    try {
-        if (!err)
-            return { message: String(err) };
-        const errAny = err;
-        if (err instanceof Error) {
-            const base = {
-                name: err.name,
-                message: err.message,
-                stack: err.stack,
-            };
-            for (const k of Object.keys(errAny))
-                base[k] = errAny[k];
-            return base;
-        }
-        if (typeof err === "object") {
-            const maybeMsg = errAny?.message;
-            const maybeName = errAny?.name;
-            const maybeStack = errAny?.stack;
-            const out = { ...errAny };
-            if (maybeMsg && !out.message)
-                out.message = String(maybeMsg);
-            if (maybeName && !out.name)
-                out.name = String(maybeName);
-            if (maybeStack && !out.stack)
-                out.stack = String(maybeStack);
-            return out;
-        }
-        return { message: String(err) };
-    }
-    catch {
-        return { message: String(err) };
-    }
-}
-
-async function handleCommand(label, env, runtimeApi, ack) {
-    const msg = env.message;
-    switch (msg.type) {
-        case "Build": {
-            console.debug(`[${label}] rx Build seq=${env.seq} nodes=${msg.payload.def.nodes?.length ?? 0} edges=${msg.payload.def.edges?.length ?? 0} envKeys=${Object.keys(msg.payload.environment ?? {}).join(",")}`);
-            await runtimeApi.build(msg.payload.def, msg.payload.environment);
-            ack();
-            break;
-        }
-        case "Update": {
-            console.debug(`[${label}] rx Update seq=${env.seq} nodes=${msg.payload.def.nodes?.length ?? 0} edges=${msg.payload.def.edges?.length ?? 0}`);
-            await runtimeApi.update(msg.payload.def);
-            ack();
-            break;
-        }
-        case "SetEnvironment": {
-            console.debug(`[${label}] rx SetEnvironment seq=${env.seq}`);
-            runtimeApi.setEnvironment(msg.payload.environment, {
-                merge: Boolean(msg.payload.merge),
-            });
-            ack();
-            break;
-        }
-        case "SetInput": {
-            console.debug(`[${label}] rx SetInput seq=${env.seq} ${msg.payload.nodeId}.${msg.payload.handle}=${summarize(msg.payload.value)}`);
-            runtimeApi.setInput(msg.payload.nodeId, msg.payload.handle, msg.payload.value);
-            ack();
-            break;
-        }
-        case "SetInputs": {
-            console.debug(`[${label}] rx SetInputs seq=${env.seq} ${msg.payload.nodeId} keys=${Object.keys(msg.payload.inputs || {}).join(",")}`);
-            const nodeId = msg.payload.nodeId;
-            const inputs = msg.payload.inputs;
-            runtimeApi.setInputs(nodeId, inputs);
-            ack();
-            break;
-        }
-        case "TriggerExternal": {
-            console.debug(`[${label}] rx TriggerExternal seq=${env.seq} ${msg.payload.nodeId} event=${summarize(msg.payload.event)}`);
-            runtimeApi.triggerExternal(msg.payload.nodeId, msg.payload.event);
-            ack();
-            break;
-        }
-        case "Launch": {
-            console.debug(`[${label}] rx Launch seq=${env.seq}`);
-            runtimeApi.launch(msg.payload.invalidate);
-            ack();
-            break;
-        }
-        case "WhenIdle": {
-            console.debug(`[${label}] rx WhenIdle seq=${env.seq}`);
-            await runtimeApi.whenIdle();
-            ack();
-            break;
-        }
-        case "Snapshot": {
-            console.debug(`[${label}] rx Snapshot seq=${env.seq}`);
-            const snap = runtimeApi.snapshot();
-            ack({ snapshot: snap });
-            break;
-        }
-        case "SnapshotFull": {
-            console.debug(`[${label}] rx SnapshotFull seq=${env.seq}`);
-            const snap = runtimeApi.snapshotFull();
-            ack({ snapshot: snap });
-            break;
-        }
-        case "GetEnvironment": {
-            console.debug(`[${label}] rx GetEnvironment seq=${env.seq}`);
-            const environment = runtimeApi.getEnvironment();
-            ack({ environment });
-            break;
-        }
-        case "ApplySnapshotFull": {
-            console.debug(`[${label}] rx ApplySnapshotFull seq=${env.seq}`);
-            await runtimeApi.applySnapshotFull(msg.payload);
-            ack();
-            break;
-        }
-        case "Coerce": {
-            console.debug(`[${label}] rx Coerce seq=${env.seq} ${msg.payload.from} -> ${msg.payload.to}`);
-            const value = await runtimeApi.coerce(msg.payload?.from, msg.payload?.to, msg.payload?.value);
-            ack({ value });
-            break;
-        }
-        case "DescribeRegistry": {
-            console.debug(`[${label}] rx DescribeRegistry seq=${env.seq}`);
-            const desc = runtimeApi.describeRegistry();
-            ack({ registry: desc });
-            break;
-        }
-        case "RegistryApply": {
-            console.debug(`[${label}] rx RegistryApply seq=${env.seq}`);
-            await runtimeApi.applyRegistry(msg.payload.deltas || []);
-            ack();
-            break;
-        }
-        case "Dispose": {
-            console.debug(`[${label}] rx Dispose seq=${env.seq}`);
-            runtimeApi.dispose();
-            ack();
-            break;
-        }
-        case "Pause":
-        case "Resume": {
-            console.debug(`[${label}] rx ${msg.type} seq=${env.seq} (not-impl)`);
-            ack();
-            break;
-        }
-        default: {
-            console.debug(`[${label}] rx Unknown type seq=${env.seq}`);
-            ack();
-        }
-    }
-}
-
-async function createRuntimeAdapter(createRegistry, send, extensions) {
-    const registry = await createRegistry();
-    const builder = new sparkGraph.GraphBuilder(registry);
-    let graphRuntime;
-    let extData = {};
-    // Helper to get current context
-    const getContext = () => ({
-        registry,
-        builder,
-        graphRuntime,
-        extData,
-    });
-    // Original implementations - define as separate functions first to allow cross-references
-    const originalApi = {
-        coerce: async (from, to, value) => {
-            const resolved = registry.resolveCoercion(from, to);
-            if (!resolved)
-                return value;
-            if (resolved.kind === "sync")
-                return resolved.convert(value);
-            const ac = new AbortController();
-            return await resolved.convertAsync(value, ac.signal);
-        },
-        getEnvironment: () => {
-            return graphRuntime?.getEnvironment?.() ?? {};
-        },
-        applyRegistry: async (deltas) => {
-            // Pause runtime if exists
-            // Apply each delta to the live registry
-            for (const d of deltas || []) {
-                if (!d || typeof d !== "object")
-                    continue;
-                if (d.kind === "register-enum") {
-                    registry.registerEnum({
-                        id: d.id,
-                        displayName: d.displayName,
-                        options: d.options || [],
-                        bakeTarget: d.bakeTarget,
-                        opts: d.opts,
-                    });
-                }
-                else if (d.kind === "register-type") {
-                    registry.registerType({
-                        id: d.id,
-                        displayName: d.displayName,
-                        bakeTarget: d.bakeTarget,
-                        validate: (_v) => true,
-                    });
-                }
-                else if (d.kind === "register-node") {
-                    const desc = d.desc || {};
-                    registry.registerNode({
-                        id: String(desc.id || ""),
-                        categoryId: String(desc.categoryId || "compute"),
-                        displayName: desc.displayName,
-                        inputs: desc.inputs || {},
-                        outputs: desc.outputs || {},
-                        // impl must be empty per frontend registration contract
-                        impl: () => { },
-                    });
-                }
-            }
-            // Notify clients (include deltas in invalidate payload)
-            send({
-                message: {
-                    type: "invalidate",
-                    payload: { reason: "registry-changed", deltas },
-                },
-            });
-        },
-        build: async (def, opts) => {
-            const env = opts || {};
-            graphRuntime = builder.build(def, { environment: env });
-            graphRuntime.on("value", (p) => send({ message: { type: "value", payload: p } }));
-            graphRuntime.on("invalidate", (p) => send({ message: { type: "invalidate", payload: p } }));
-            graphRuntime.on("error", (p) => send({ message: { type: "error", payload: p } }));
-            graphRuntime.on("stats", (p) => send({ message: { type: "stats", payload: p } }));
-        },
-        setExtData: (data) => {
-            if (!data || typeof data !== "object") {
-                extData = {};
-                return;
-            }
-            // Replace to keep semantics deterministic
-            extData = { ...data };
-        },
-        getExtData: () => {
-            return extData;
-        },
-        snapshot: () => {
-            const inputs = {};
-            const outputs = {};
-            if (!graphRuntime)
-                return { inputs, outputs };
-            const nodes = graphRuntime.getNodeIds();
-            for (const nodeId of nodes) {
-                const data = graphRuntime.getNodeData(nodeId);
-                if (data?.inputs && Object.keys(data.inputs).length > 0) {
-                    inputs[nodeId] = { ...data.inputs };
-                }
-                if (data?.outputs && Object.keys(data.outputs).length > 0) {
-                    outputs[nodeId] = { ...data.outputs };
-                }
-            }
-            return { inputs, outputs };
-        },
-        snapshotFull: () => {
-            const snap = originalApi.snapshot();
-            const env = graphRuntime?.getEnvironment?.() ?? {};
-            const def = graphRuntime?.getGraphDef();
-            return {
-                def,
-                environment: env,
-                inputs: snap.inputs,
-                outputs: snap.outputs,
-            };
-        },
-        applySnapshotFull: async (payload) => {
-            const def = payload.def;
-            if (!def)
-                return;
-            await originalApi.build(def, payload.environment);
-            // Hydrate inputs/outputs exactly, then re-emit outputs without scheduling runs
-            graphRuntime?.hydrate({
-                inputs: payload.inputs,
-                outputs: payload.outputs,
-            });
-        },
-        describeRegistry: () => {
-            // types (include enum options when available)
-            const types = Array.from(registry.types.entries()).map(([id, d]) => {
-                const en = registry.enums.get(id);
-                return {
-                    id,
-                    displayName: d.displayName,
-                    bakeTarget: d.bakeTarget,
-                    ...(en ? { options: en.options } : {}),
-                };
-            });
-            // categories: not directly enumerable; derive from node descriptors
-            const nodeDescs = Array.from(registry.nodes.values());
-            const catIds = new Set(nodeDescs.map((n) => n.categoryId));
-            const categories = Array.from(catIds).map((id) => {
-                const cat = registry.categories.get?.(id);
-                return { id, displayName: cat?.displayName };
-            });
-            const nodes = nodeDescs.map((n) => ({
-                id: n.id,
-                categoryId: n.categoryId,
-                displayName: n.displayName,
-                inputs: n.inputs || {},
-                outputs: n.outputs || {},
-                inputDefaults: n.inputDefaults || {},
-            }));
-            const coercions = registry.listCoercions();
-            return { types, categories, nodes, coercions, schemaVersion: 4 };
-        },
-        update: async (def) => {
-            if (!graphRuntime)
-                return;
-            graphRuntime.update(def, registry);
-            send({
-                message: {
-                    type: "invalidate",
-                    payload: { reason: "graph-updated" },
-                },
-            });
-        },
-        setEnvironment: (env, opts) => {
-            if (!graphRuntime)
-                return;
-            if (opts?.merge) {
-                const current = graphRuntime.getEnvironment();
-                const next = { ...(current || {}), ...(env || {}) };
-                graphRuntime.setEnvironment(next);
-                return;
-            }
-            graphRuntime.setEnvironment(env);
-        },
-        setInput: (nodeId, handle, value) => {
-            graphRuntime?.setInput(nodeId, handle, value);
-        },
-        setInputs: (nodeId, inputs) => {
-            graphRuntime?.setInputs(nodeId, inputs);
-        },
-        triggerExternal: (nodeId, event) => {
-            graphRuntime?.triggerExternal(nodeId, event);
-        },
-        launch: (invalidate) => {
-            graphRuntime?.launch(invalidate);
-        },
-        whenIdle: () => {
-            return graphRuntime?.whenIdle?.() ?? Promise.resolve();
-        },
-        dispose: () => {
-            graphRuntime?.dispose?.();
-            graphRuntime = undefined;
-        },
-    };
-    // Helper to wrap a method with extension support
-    const wrapMethod = (key, original) => {
-        const extension = extensions?.[key];
-        if (!extension) {
-            return original;
-        }
-        return ((...args) => {
-            return extension(original, getContext(), ...args);
-        });
-    };
-    // Create API with extensions applied
-    const extendedApi = {
-        coerce: wrapMethod("coerce", originalApi.coerce),
-        getEnvironment: wrapMethod("getEnvironment", originalApi.getEnvironment),
-        applyRegistry: wrapMethod("applyRegistry", originalApi.applyRegistry),
-        build: wrapMethod("build", originalApi.build),
-        setExtData: wrapMethod("setExtData", originalApi.setExtData),
-        getExtData: wrapMethod("getExtData", originalApi.getExtData),
-        snapshot: wrapMethod("snapshot", originalApi.snapshot),
-        snapshotFull: wrapMethod("snapshotFull", originalApi.snapshotFull),
-        applySnapshotFull: wrapMethod("applySnapshotFull", originalApi.applySnapshotFull),
-        describeRegistry: wrapMethod("describeRegistry", originalApi.describeRegistry),
-        update: wrapMethod("update", originalApi.update),
-        setEnvironment: wrapMethod("setEnvironment", originalApi.setEnvironment),
-        setInput: wrapMethod("setInput", originalApi.setInput),
-        setInputs: wrapMethod("setInputs", originalApi.setInputs),
-        triggerExternal: wrapMethod("triggerExternal", originalApi.triggerExternal),
-        launch: wrapMethod("launch", originalApi.launch),
-        whenIdle: wrapMethod("whenIdle", originalApi.whenIdle),
-        dispose: wrapMethod("dispose", originalApi.dispose),
-    };
-    return extendedApi;
-}
-
-exports.HttpPollingTransport = HttpPollingTransport;
-exports.RemoteEngine = RemoteEngine;
-exports.RemoteRunner = RemoteRunner;
-exports.WebSocketTransport = WebSocketTransport;
-exports.createRuntimeAdapter = createRuntimeAdapter;
-exports.handleCommand = handleCommand;
-exports.serializeError = serializeError;
-exports.summarize = summarize;
+exports.HttpPollingTransport = index.HttpPollingTransport;
+exports.RemoteEngine = index.RemoteEngine;
+exports.RuntimeApiClient = index.RuntimeApiClient;
+exports.RuntimeApiServer = index.RuntimeApiServer;
+exports.WebSocketTransport = index.WebSocketTransport;
+exports.createRuntimeAdapter = index.createRuntimeAdapter;
+exports.serializeError = index.serializeError;
+exports.summarize = index.summarize;
 //# sourceMappingURL=index.cjs.map