@bian-womp/spark-remote 0.2.93 → 0.3.0

package/lib/cjs/index.cjs

@@ -372,7 +372,7 @@ function serializeError(err) {
     }
 }
 
-async function createRuntimeAdapter(id, createRegistry, send, extensions) {
+async function createServerRuntimeAdapter(id, createRegistry, send, extensions) {
     const registry = await createRegistry(id);
     const builder = new sparkGraph.GraphBuilder(registry);
     let graphRuntime;
@@ -387,7 +387,7 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
         extData,
     });
     // Original implementations - define as separate functions first to allow cross-references
-    const originalApi = {
+    const originalAdapter = {
         coerce: async (from, to, value) => {
             const resolved = registry.resolveCoercion(from, to);
             if (!resolved)
@@ -397,7 +397,7 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
             const ac = new AbortController();
             return await resolved.convertAsync(value, ac.signal);
         },
-        getEnvironment: () => {
+        getEnvironment: async () => {
             return graphRuntime?.getEnvironment?.() ?? {};
         },
         applyRegistry: async (deltas) => {
@@ -445,14 +445,14 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
             });
         },
         build: async (def, opts) => {
-            const env = opts || {};
+            const env = opts?.environment || {};
             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) => {
+        setExtData: async (data) => {
             if (!data || typeof data !== "object") {
                 // Clear all extData when called with non-object (backward-compatible)
                 extData = {};
@@ -462,10 +462,10 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
             // (e.g., { ui } or { runtime }) without dropping the other ones.
             extData = { ...extData, ...data };
         },
-        getExtData: () => {
+        getExtData: async () => {
             return extData;
         },
-        snapshot: () => {
+        snapshot: async () => {
             const inputs = {};
             const outputs = {};
             if (!graphRuntime)
@@ -482,9 +482,9 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
             }
             return { inputs, outputs };
         },
-        snapshotFull: () => {
-            const snap = originalApi.snapshot();
-            const extData = originalApi.getExtData();
+        snapshotFull: async () => {
+            const snap = await originalAdapter.snapshot();
+            const extData = await originalAdapter.getExtData();
             const env = graphRuntime?.getEnvironment?.() ?? {};
             const def = graphRuntime?.getGraphDef();
             return {
@@ -501,27 +501,31 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
                 return;
             // Only build if skipBuild is not true
             if (!options?.skipBuild) {
-                await originalApi.build(def, payload.environment);
+                await originalAdapter.build(def, { environment: payload.environment });
             }
             else if (!graphRuntime) {
                 // If skipping build but no runtime exists, we still need to build
                 console.info("Skipping build is set but no runtime exists, building anyway");
-                await originalApi.build(def, payload.environment);
+                await originalAdapter.build(def, { environment: payload.environment });
             }
             // Hydrate inputs/outputs exactly, then re-emit outputs without scheduling runs
             graphRuntime?.hydrate({
                 inputs: payload.inputs,
                 outputs: payload.outputs,
             });
-            originalApi.setExtData(payload.extData || {});
+            await originalAdapter.setExtData(payload.extData || {});
         },
         cancelNodeRuns: (nodeIds) => {
-            graphRuntime?.cancelNodeRuns(nodeIds);
+            if (!graphRuntime)
+                return;
+            graphRuntime.cancelNodeRuns(nodeIds);
+        },
+        commit: async (reason) => {
+            return undefined;
         },
-        commit: async (reason) => { },
         undo: async () => false,
         redo: async () => false,
-        describeRegistry: () => {
+        describeRegistry: async () => {
             // types (include enum options when available)
             const types = Array.from(registry.types.entries()).map(([id, d]) => {
                 const en = registry.enums.get(id);
@@ -570,7 +574,7 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
                     graphRuntime.resume();
             }
         },
-        setEnvironment: (env, opts) => {
+        setEnvironment: async (env, opts) => {
             if (!graphRuntime)
                 return;
             const wasPaused = graphRuntime.isPaused();
@@ -592,54 +596,21 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
             }
         },
         setInputs: (nodeId, inputs, options) => {
-            if (!graphRuntime)
+            if (!engine)
                 return;
-            const wasPaused = graphRuntime.isPaused();
-            if (options?.dry && !wasPaused)
-                graphRuntime.pause();
-            try {
-                if (engine) {
-                    engine.setInputs(nodeId, inputs);
-                }
-                else {
-                    graphRuntime.setInputs(nodeId, inputs);
-                }
-            }
-            finally {
-                if (options?.dry && !wasPaused)
-                    graphRuntime.resume();
-            }
+            engine.setInputs(nodeId, inputs, options);
         },
         copyOutputs: (fromNodeId, toNodeId, options) => {
-            if (!graphRuntime)
-                return;
-            // Get outputs from source node
-            const fromNode = graphRuntime.getNodeData(fromNodeId);
-            if (!fromNode?.outputs)
+            if (!engine)
                 return;
-            // Copy outputs to target node using hydrate
-            graphRuntime.hydrate({ outputs: { [toNodeId]: { ...fromNode.outputs } } }, { reemit: !options?.dry });
+            engine.copyOutputs(fromNodeId, toNodeId, options);
         },
         triggerExternal: (nodeId, event, options) => {
-            if (!graphRuntime)
+            if (!engine)
                 return;
-            const wasPaused = graphRuntime.isPaused();
-            if (options?.dry && !wasPaused)
-                graphRuntime.pause();
-            try {
-                if (engine) {
-                    engine.triggerExternal(nodeId, event);
-                }
-                else {
-                    graphRuntime.triggerExternal(nodeId, event);
-                }
-            }
-            finally {
-                if (options?.dry && !wasPaused)
-                    graphRuntime.resume();
-            }
+            engine.triggerExternal(nodeId, event, options);
         },
-        launch: (opts) => {
+        launch: async (opts) => {
             if (!graphRuntime) {
                 throw new Error("Cannot launch: graph runtime not built");
             }
@@ -649,49 +620,52 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
                 engine = undefined;
             }
             // Create new engine using shared factory
-            engine = sparkGraph.createEngine(graphRuntime, opts);
-            // Launch the engine
-            if (engine) {
-                engine.launch(opts?.invalidate);
-            }
+            engine = new sparkGraph.UnifiedEngine(graphRuntime, opts?.runMode);
+            engine.launch(opts?.invalidate);
         },
-        step: async () => {
+        setRunMode: (runMode) => {
             if (!engine)
                 return;
-            // Type guard for StepEngine
-            if ("step" in engine && typeof engine.step === "function") {
-                await engine.step();
-            }
+            engine.setRunMode(runMode);
         },
-        computeNode: async (nodeId) => {
+        computeNode: async (nodeId, options) => {
             if (!engine)
                 return;
-            // Type guard for PullEngine
-            if ("computeNode" in engine && typeof engine.computeNode === "function") {
-                await engine.computeNode(nodeId);
-            }
+            await engine.computeNode(nodeId, options);
         },
-        flush: async () => {
+        runFromHere: async (nodeId) => {
             if (!engine)
                 return;
-            // Type guard for BatchedEngine
-            if ("flush" in engine && typeof engine.flush === "function") {
-                await engine.flush();
-            }
+            await engine.runFromHere(nodeId);
         },
-        whenIdle: () => {
-            if (engine) {
-                return engine.whenIdle();
-            }
-            return graphRuntime?.whenIdle?.() ?? Promise.resolve();
+        whenIdle: async () => {
+            if (!engine)
+                return;
+            await engine.whenIdle();
         },
         dispose: () => {
             if (engine) {
                 engine.dispose();
                 engine = undefined;
             }
-            graphRuntime?.dispose?.();
-            graphRuntime = undefined;
+            if (graphRuntime) {
+                graphRuntime.dispose();
+                graphRuntime = undefined;
+            }
+        },
+        // Engine methods
+        getOutput: (nodeId, output) => {
+            return engine?.getOutput(nodeId, output);
+        },
+        on: (event, handler) => {
+            if (!engine)
+                return () => { };
+            return engine.on(event, handler);
+        },
+        // GraphLifecycleApi methods
+        setViewport: async (viewport) => {
+            // Viewport is UI-specific, server doesn't need to handle it
+            // But we implement it to satisfy the interface
         },
     };
     // Helper to wrap a method with extension support
@@ -709,34 +683,39 @@ async function createRuntimeAdapter(id, createRegistry, send, extensions) {
         });
     };
     // 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),
-        setInputs: wrapMethod("setInputs", originalApi.setInputs),
-        copyOutputs: wrapMethod("copyOutputs", originalApi.copyOutputs),
-        triggerExternal: wrapMethod("triggerExternal", originalApi.triggerExternal),
-        step: wrapMethod("step", originalApi.step),
-        computeNode: wrapMethod("computeNode", originalApi.computeNode),
-        flush: wrapMethod("flush", originalApi.flush),
-        launch: wrapMethod("launch", originalApi.launch),
-        whenIdle: wrapMethod("whenIdle", originalApi.whenIdle),
-        dispose: wrapMethod("dispose", originalApi.dispose),
-        commit: wrapMethod("commit", originalApi.commit),
-        cancelNodeRuns: wrapMethod("cancelNodeRuns", originalApi.cancelNodeRuns),
-        undo: wrapMethod("undo", originalApi.undo),
-        redo: wrapMethod("redo", originalApi.redo),
+    const extendedAdapter = {
+        // GraphLifecycleApi methods
+        coerce: wrapMethod("coerce", originalAdapter.coerce),
+        getEnvironment: wrapMethod("getEnvironment", originalAdapter.getEnvironment),
+        applyRegistry: wrapMethod("applyRegistry", originalAdapter.applyRegistry),
+        build: wrapMethod("build", originalAdapter.build),
+        setExtData: wrapMethod("setExtData", originalAdapter.setExtData),
+        getExtData: wrapMethod("getExtData", originalAdapter.getExtData),
+        snapshot: wrapMethod("snapshot", originalAdapter.snapshot),
+        snapshotFull: wrapMethod("snapshotFull", originalAdapter.snapshotFull),
+        applySnapshotFull: wrapMethod("applySnapshotFull", originalAdapter.applySnapshotFull),
+        describeRegistry: wrapMethod("describeRegistry", originalAdapter.describeRegistry),
+        update: wrapMethod("update", originalAdapter.update),
+        setEnvironment: wrapMethod("setEnvironment", originalAdapter.setEnvironment),
+        setViewport: wrapMethod("setViewport", originalAdapter.setViewport),
+        commit: wrapMethod("commit", originalAdapter.commit),
+        undo: wrapMethod("undo", originalAdapter.undo),
+        redo: wrapMethod("redo", originalAdapter.redo),
+        launch: wrapMethod("launch", originalAdapter.launch),
+        // Engine methods
+        setInputs: wrapMethod("setInputs", originalAdapter.setInputs),
+        copyOutputs: wrapMethod("copyOutputs", originalAdapter.copyOutputs),
+        triggerExternal: wrapMethod("triggerExternal", originalAdapter.triggerExternal),
+        computeNode: wrapMethod("computeNode", originalAdapter.computeNode),
+        runFromHere: wrapMethod("runFromHere", originalAdapter.runFromHere),
+        setRunMode: wrapMethod("setRunMode", originalAdapter.setRunMode),
+        whenIdle: wrapMethod("whenIdle", originalAdapter.whenIdle),
+        dispose: wrapMethod("dispose", originalAdapter.dispose),
+        cancelNodeRuns: wrapMethod("cancelNodeRuns", originalAdapter.cancelNodeRuns),
+        getOutput: wrapMethod("getOutput", originalAdapter.getOutput),
+        on: wrapMethod("on", originalAdapter.on),
     };
-    return extendedApi;
+    return extendedAdapter;
 }
 
 const UNSET_MARKER = { __spark_unset: true };
@@ -790,11 +769,19 @@ class RemoteEngine {
             this.emit("stats", msg.payload);
         }
     }
-    launch(invalidate, engineConfig) {
+    launch(invalidate, runMode) {
         this.transport.send({
             message: {
                 type: "Launch",
-                payload: { invalidate, ...engineConfig },
+                payload: { runMode, invalidate },
+            },
+        });
+    }
+    setRunMode(runMode) {
+        this.transport.send({
+            message: {
+                type: "SetRunMode",
+                payload: { runMode },
             },
         });
     }
@@ -845,11 +832,187 @@ class RemoteEngine {
     async whenIdle() {
         await this.transport.request({ message: { type: "WhenIdle" } });
     }
+    async computeNode(nodeId, options) {
+        await this.transport.request({
+            message: { type: "ComputeNode", payload: { nodeId, ...options } },
+        });
+    }
+    async runFromHere(nodeId) {
+        await this.transport.request({
+            message: { type: "RunFromHere", payload: { nodeId } },
+        });
+    }
+    async cancelNodeRuns(nodeIds) {
+        await this.transport.request({
+            message: { type: "CancelNodeRuns", payload: { nodeIds } },
+        });
+    }
     dispose() {
         this.transport.send({ message: { type: "Dispose" } });
     }
 }
 
+/**
+ * RemoteGraphLifecycleApi implements GraphLifecycleApi by sending commands over transport.
+ * This handles all non-execution operations (graph lifecycle, snapshots, registry, etc.)
+ */
+class RemoteGraphLifecycleApi {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async ensureConnected() {
+        if (!this.transport) {
+            throw new Error("Transport not connected");
+        }
+        return this.transport;
+    }
+    async build(def, opts) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: {
+                type: "Build",
+                payload: { def, environment: opts?.environment },
+            },
+        });
+    }
+    async update(def, options) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: { type: "Update", payload: { def }, dry: options?.dry },
+        });
+    }
+    async launch(opts) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: {
+                type: "Launch",
+                payload: opts,
+            },
+        });
+    }
+    async snapshot() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "Snapshot" },
+        });
+        const payload = res?.message || {};
+        return payload.snapshot || { inputs: {}, outputs: {} };
+    }
+    async snapshotFull() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "SnapshotFull" },
+        });
+        const payload = res?.message || {};
+        return (payload.snapshot || {
+            def: undefined,
+            environment: {},
+            inputs: {},
+            outputs: {},
+        });
+    }
+    async applySnapshotFull(payload, options) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: {
+                type: "ApplySnapshotFull",
+                payload,
+                skipBuild: options?.skipBuild,
+            },
+        });
+    }
+    async describeRegistry() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "DescribeRegistry" },
+        });
+        const payload = res?.message || {};
+        return (payload.registry || {
+            types: [],
+            categories: [],
+            nodes: [],
+            coercions: [],
+            schemaVersion: 4,
+        });
+    }
+    async applyRegistry(deltas) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: { type: "RegistryApply", payload: { deltas } },
+        });
+    }
+    async setEnvironment(environment, opts) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: {
+                type: "SetEnvironment",
+                payload: { environment, merge: opts?.merge },
+                dry: opts?.dry,
+            },
+        });
+    }
+    async getEnvironment() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "GetEnvironment" },
+        });
+        const payload = res?.message || {};
+        return payload.environment || {};
+    }
+    async coerce(from, to, value) {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "Coerce", payload: { from, to, value } },
+        });
+        const payload = res?.message || {};
+        return payload.value;
+    }
+    async setExtData(data) {
+        const transport = await this.ensureConnected();
+        await transport.request({
+            message: { type: "SetExtData", payload: data },
+        });
+    }
+    async getExtData() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "GetExtData" },
+        });
+        const payload = res?.message || {};
+        return payload.extData || {};
+    }
+    async setViewport(viewport) {
+        const transport = await this.ensureConnected();
+        await transport.send({
+            message: { type: "SetViewport", payload: { viewport } },
+        });
+    }
+    async commit(reason) {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "Commit", payload: { reason } },
+        });
+        const payload = res?.message || {};
+        return payload.history;
+    }
+    async undo() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "Undo" },
+        });
+        const payload = res?.message || {};
+        return payload.success ?? false;
+    }
+    async redo() {
+        const transport = await this.ensureConnected();
+        const res = await transport.request({
+            message: { type: "Redo" },
+        });
+        const payload = res?.message || {};
+        return payload.success ?? false;
+    }
+}
+
 // Node-only transport using a UNIX domain socket.
 // Import directly from path: "@bian-womp/spark-remote/transport/UnixSocketTransport" in Node/Electron code.
 // Do not re-export from the browser index to avoid bundling in web builds.
@@ -945,7 +1108,33 @@ class UnixSocketTransport {
     }
 }
 
-class RuntimeApiClient {
+/**
+ * RemoteRuntimeClient manages the connection to a remote runtime.
+ * It provides access to:
+ * - engine: RemoteEngine for execution operations
+ * - api: GraphLifecycleApi for graph lifecycle operations
+ */
+class RemoteRuntimeClient {
+    /**
+     * Get the Engine instance for execution operations.
+     * Engine provides unified interface for local/remote execution.
+     */
+    get engine() {
+        if (!this._engine) {
+            throw new Error("Engine not available: call connect() first");
+        }
+        return this._engine;
+    }
+    /**
+     * Get the GraphLifecycleApi instance for non-execution operations.
+     * GraphLifecycleApi handles graph lifecycle, snapshots, registry, environment, etc.
+     */
+    get api() {
+        if (!this._api) {
+            throw new Error("GraphLifecycleApi not available: call connect() first");
+        }
+        return this._api;
+    }
     constructor(config, options) {
         this.customEventListeners = new Set();
         this.transportEventListeners = new Set();
@@ -976,7 +1165,7 @@ class RuntimeApiClient {
             return new WebSocketTransport(this.config.url, {
                 onConnectionLost: () => {
                     this.dispose().catch((err) => {
-                        console.warn("[RuntimeApiClient] Error disposing on connection loss:", err);
+                        console.warn("[RemoteRuntimeClient] Error disposing on connection loss:", err);
                     });
                 },
                 connector: this.config.connectOptions?.connector,
@@ -997,7 +1186,7 @@ class RuntimeApiClient {
      */
     async connect() {
         if (this.disposed) {
-            throw new Error("Cannot connect: RuntimeApiClient has been disposed");
+            throw new Error("Cannot connect: RemoteRuntimeClient has been disposed");
         }
         if (this.transport) {
             // Already connected
@@ -1022,8 +1211,9 @@ class RuntimeApiClient {
                 this.transportUnsubscribe = transport.subscribe((event) => {
                     this.handleTransportEvent(event);
                 });
-                // Create engine with connected transport
-                this.engine = new RemoteEngine(transport);
+                // Create engine and api with connected transport
+                this._engine = new RemoteEngine(transport);
+                this._api = new RemoteGraphLifecycleApi(transport);
                 this.emitTransportStatus({
                     state: "connected",
                     kind: this.config.kind,
@@ -1089,184 +1279,6 @@ class RuntimeApiClient {
             listener(status);
         }
     }
-    /**
-     * Ensure transport is connected. Called automatically by API methods.
-     * Returns the transport instance, throwing if connection fails or client is disposed.
-     */
-    async ensureConnected() {
-        if (this.disposed) {
-            throw new Error("Cannot ensure connection: RuntimeApiClient has been disposed");
-        }
-        if (!this.transport) {
-            await this.connect();
-        }
-        // After connect(), transport is guaranteed to be set
-        if (!this.transport) {
-            throw new Error("Failed to establish transport connection");
-        }
-        return this.transport;
-    }
-    async build(def, opts) {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: {
-                type: "Build",
-                payload: { def, environment: opts?.environment },
-            },
-        });
-    }
-    async update(def, options) {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: { type: "Update", payload: { def }, dry: options?.dry },
-        });
-    }
-    async describeRegistry() {
-        const transport = await this.ensureConnected();
-        const res = await transport.request({
-            message: { type: "DescribeRegistry" },
-        });
-        const payload = res?.message || {};
-        return (payload.registry || {
-            types: [],
-            categories: [],
-            nodes: [],
-            coercions: [],
-            schemaVersion: 4,
-        });
-    }
-    async applyRegistry(deltas) {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: { type: "RegistryApply", payload: { deltas } },
-        });
-    }
-    async snapshot() {
-        const transport = await this.ensureConnected();
-        const res = await transport.request({
-            message: { type: "Snapshot" },
-        });
-        const payload = res?.message || {};
-        return payload.snapshot || { inputs: {}, outputs: {} };
-    }
-    async snapshotFull() {
-        const transport = await this.ensureConnected();
-        const res = await transport.request({
-            message: { type: "SnapshotFull" },
-        });
-        const payload = res?.message || {};
-        return (payload.snapshot || {
-            def: undefined,
-            environment: {},
-            inputs: {},
-            outputs: {},
-        });
-    }
-    async applySnapshotFull(payload, options) {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: {
-                type: "ApplySnapshotFull",
-                payload,
-                skipBuild: options?.skipBuild,
-            },
-        });
-    }
-    async setEnvironment(environment, opts) {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: {
-                type: "SetEnvironment",
-                payload: { environment, merge: opts?.merge },
-                dry: opts?.dry,
-            },
-        });
-    }
-    async getEnvironment() {
-        const transport = await this.ensureConnected();
-        const res = await transport.request({
-            message: { type: "GetEnvironment" },
-        });
-        const payload = res?.message || {};
-        return payload.environment || {};
-    }
-    async coerce(from, to, value) {
-        const transport = await this.ensureConnected();
-        const res = await transport.request({
-            message: { type: "Coerce", payload: { from, to, value } },
-        });
-        const payload = res?.message || {};
-        return payload.value;
-    }
-    getEngine() {
-        if (!this.engine) {
-            throw new Error("Engine not available: call connect() first");
-        }
-        return this.engine;
-    }
-    async launch(opts) {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: {
-                type: "Launch",
-                payload: opts,
-            },
-        });
-    }
-    async step() {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: { type: "Step" },
-        });
-    }
-    async computeNode(nodeId) {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: { type: "ComputeNode", payload: { nodeId } },
-        });
-    }
-    async flush() {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: { type: "Flush" },
-        });
-    }
-    async setExtData(data) {
-        const transport = await this.ensureConnected();
-        await transport.request({
-            message: { type: "SetExtData", payload: data },
-        });
-    }
-    async commit(reason) {
-        const transport = await this.ensureConnected();
-        const res = await transport.request({
-            message: { type: "Commit", payload: { reason } },
-        });
-        const payload = res?.message || {};
-        return payload.history;
-    }
-    async undo() {
-        const transport = await this.ensureConnected();
-        const res = await transport.request({
-            message: { type: "Undo" },
-        });
-        const payload = res?.message || {};
-        return payload.success ?? false;
-    }
-    async redo() {
-        const transport = await this.ensureConnected();
-        const res = await transport.request({
-            message: { type: "Redo" },
-        });
-        const payload = res?.message || {};
-        return payload.success ?? false;
-    }
-    async setViewport(viewport) {
-        const transport = await this.ensureConnected();
-        await transport.send({
-            message: { type: "SetViewport", payload: { viewport } },
-        });
-    }
     /**
      * Dispose the client and close the transport connection.
      * Idempotent: safe to call multiple times.
@@ -1286,9 +1298,10 @@ class RuntimeApiClient {
         if (this.transport) {
             const transportToClose = this.transport;
             this.transport = undefined;
-            this.engine = undefined; // Clear engine reference
+            this._engine = undefined; // Clear engine reference
+            this._api = undefined; // Clear api reference
             await transportToClose.close().catch((err) => {
-                console.warn("[RuntimeApiClient] Error closing transport:", err);
+                console.warn("[RemoteRuntimeClient] Error closing transport:", err);
             });
         }
         // Clear listeners
@@ -1302,9 +1315,9 @@ class RuntimeApiClient {
     }
 }
 
-class RuntimeApiServer {
-    constructor(runtimeApi, options) {
-        this.runtimeApi = runtimeApi;
+class ServerCommandHandler {
+    constructor(adapter, options) {
+        this.adapter = adapter;
         this.options = options;
         this.middlewares = [];
     }
@@ -1356,7 +1369,7 @@ class RuntimeApiServer {
                     edges: msg.payload.def.edges?.length ?? 0,
                     envKeys: Object.keys(msg.payload.environment ?? {}).join(","),
                 });
-                await this.runtimeApi.build(msg.payload.def, msg.payload.environment);
+                await this.adapter.build(msg.payload.def, msg.payload.environment);
                 ack();
                 break;
             }
@@ -1367,14 +1380,14 @@ class RuntimeApiServer {
                     edges: msg.payload.def.edges?.length ?? 0,
                     dry: !!dry,
                 });
-                await this.runtimeApi.update(msg.payload.def, { dry });
+                await this.adapter.update(msg.payload.def, { dry });
                 ack();
                 break;
             }
             case "SetEnvironment": {
                 const dry = msg.dry;
                 this.logCommand("SetEnvironment", env, dry ? { dry: true } : undefined);
-                this.runtimeApi.setEnvironment(msg.payload.environment, {
+                this.adapter.setEnvironment(msg.payload.environment, {
                     merge: Boolean(msg.payload.merge),
                     dry,
                 });
@@ -1390,7 +1403,7 @@ class RuntimeApiServer {
                 });
                 const nodeId = msg.payload.nodeId;
                 const inputs = decodeInputsFromTransport(msg.payload.inputs);
-                this.runtimeApi.setInputs(nodeId, inputs, { dry });
+                this.adapter.setInputs(nodeId, inputs, { dry });
                 ack();
                 break;
             }
@@ -1401,7 +1414,9 @@ class RuntimeApiServer {
                     toNodeId: msg.payload.toNodeId,
                     dry: !!dry,
                 });
-                this.runtimeApi.copyOutputs(msg.payload.fromNodeId, msg.payload.toNodeId, { dry });
+                this.adapter.copyOutputs(msg.payload.fromNodeId, msg.payload.toNodeId, {
+                    dry,
+                });
                 ack();
                 break;
             }
@@ -1412,7 +1427,7 @@ class RuntimeApiServer {
                     event: summarize(msg.payload.event),
                     dry: !!dry,
                 });
-                this.runtimeApi.triggerExternal(msg.payload.nodeId, msg.payload.event, {
+                this.adapter.triggerExternal(msg.payload.nodeId, msg.payload.event, {
                     dry,
                 });
                 ack();
@@ -1423,72 +1438,70 @@ class RuntimeApiServer {
             case "Launch": {
                 const launchPayload = msg.payload;
                 this.logCommand("Launch", env, {
-                    engine: launchPayload.engine,
-                    invalidate: launchPayload.invalidate,
-                });
-                this.runtimeApi.launch({
+                    runMode: launchPayload.runMode,
                     invalidate: launchPayload.invalidate,
-                    engine: launchPayload.engine,
-                    batched: launchPayload.batched,
-                    hybrid: launchPayload.hybrid,
                 });
+                this.adapter.launch(launchPayload);
                 ack();
                 break;
             }
-            case "Step": {
-                this.logCommand("Step", env);
-                if (this.runtimeApi.step) {
-                    await this.runtimeApi.step();
-                }
+            case "SetRunMode": {
+                const setRunModePayload = msg.payload;
+                this.logCommand("SetRunMode", env, setRunModePayload);
+                this.adapter.setRunMode(setRunModePayload.runMode);
                 ack();
                 break;
             }
             case "ComputeNode": {
-                this.logCommand("ComputeNode", env, {
+                const computeNodePayload = msg.payload;
+                this.logCommand("ComputeNode", env, computeNodePayload);
+                await this.adapter.computeNode(computeNodePayload.nodeId, computeNodePayload);
+                ack();
+                break;
+            }
+            case "RunFromHere": {
+                this.logCommand("RunFromHere", env, {
                     nodeId: msg.payload.nodeId,
                 });
-                if (this.runtimeApi.computeNode) {
-                    await this.runtimeApi.computeNode(msg.payload.nodeId);
-                }
+                await this.adapter.runFromHere(msg.payload.nodeId);
                 ack();
                 break;
             }
-            case "Flush": {
-                this.logCommand("Flush", env);
-                if (this.runtimeApi.flush) {
-                    await this.runtimeApi.flush();
-                }
+            case "CancelNodeRuns": {
+                const cancelPayload = msg.payload;
+                this.logCommand("CancelNodeRuns", env, cancelPayload);
+                this.adapter.cancelNodeRuns(cancelPayload.nodeIds);
                 ack();
                 break;
             }
             case "WhenIdle": {
                 this.logCommand("WhenIdle", env);
-                await this.runtimeApi.whenIdle();
+                await this.adapter.whenIdle();
                 ack();
                 break;
             }
             case "Snapshot": {
                 this.logCommand("Snapshot", env);
-                const snap = this.runtimeApi.snapshot();
+                const snap = this.adapter.snapshot();
                 ack({ snapshot: snap });
                 break;
             }
             case "SnapshotFull": {
                 this.logCommand("SnapshotFull", env);
-                const snap = this.runtimeApi.snapshotFull();
+                const snap = this.adapter.snapshotFull();
                 ack({ snapshot: snap });
                 break;
             }
             case "GetEnvironment": {
                 this.logCommand("GetEnvironment", env);
-                const environment = this.runtimeApi.getEnvironment();
+                const environment = this.adapter.getEnvironment();
                 ack({ environment });
                 break;
             }
             case "ApplySnapshotFull": {
                 const skipBuild = msg.skipBuild;
                 this.logCommand("ApplySnapshotFull", env, skipBuild ? { skipBuild: true } : undefined);
-                await this.runtimeApi.applySnapshotFull(msg.payload, { skipBuild });
+                await this.adapter.applySnapshotFull(msg.payload, { skipBuild });
                 ack();
                 break;
             }
@@ -1497,48 +1510,48 @@ class RuntimeApiServer {
                     from: msg.payload.from,
                     to: msg.payload.to,
                 });
-                const value = await this.runtimeApi.coerce(msg.payload.from, msg.payload.to, msg.payload.value);
+                const value = await this.adapter.coerce(msg.payload.from, msg.payload.to, msg.payload.value);
                 ack({ value });
                 break;
             }
             case "DescribeRegistry": {
                 this.logCommand("DescribeRegistry", env);
-                const desc = this.runtimeApi.describeRegistry();
+                const desc = this.adapter.describeRegistry();
                 ack({ registry: desc });
                 break;
             }
             case "RegistryApply": {
                 this.logCommand("RegistryApply", env);
-                await this.runtimeApi.applyRegistry(msg.payload.deltas || []);
+                await this.adapter.applyRegistry(msg.payload.deltas || []);
                 ack();
                 break;
             }
             case "SetExtData": {
-                this.runtimeApi.setExtData(msg.payload);
+                this.adapter.setExtData(msg.payload);
                 ack();
                 break;
             }
             case "Dispose": {
                 this.logCommand("Dispose", env);
-                this.runtimeApi.dispose();
+                this.adapter.dispose();
                 ack();
                 break;
             }
             case "Commit": {
                 this.logCommand("Commit", env);
-                const history = await this.runtimeApi.commit(msg.payload.reason);
+                const history = await this.adapter.commit(msg.payload.reason);
                 ack(history ? { history } : undefined);
                 break;
             }
             case "Undo": {
                 this.logCommand("Undo", env);
-                const success = await this.runtimeApi.undo();
+                const success = await this.adapter.undo();
                 ack({ success });
                 break;
             }
             case "Redo": {
                 this.logCommand("Redo", env);
-                const success = await this.runtimeApi.redo();
+                const success = await this.adapter.redo();
                 ack({ success });
                 break;
             }
@@ -1606,10 +1619,11 @@ class RuntimeApiServer {
 
 exports.HttpPollingTransport = HttpPollingTransport;
 exports.RemoteEngine = RemoteEngine;
-exports.RuntimeApiClient = RuntimeApiClient;
-exports.RuntimeApiServer = RuntimeApiServer;
+exports.RemoteGraphLifecycleApi = RemoteGraphLifecycleApi;
+exports.RemoteRuntimeClient = RemoteRuntimeClient;
+exports.ServerCommandHandler = ServerCommandHandler;
 exports.WebSocketTransport = WebSocketTransport;
-exports.createRuntimeAdapter = createRuntimeAdapter;
+exports.createServerRuntimeAdapter = createServerRuntimeAdapter;
 exports.serializeError = serializeError;
 exports.summarize = summarize;
 //# sourceMappingURL=index.cjs.map