@bian-womp/spark-remote 0.2.47 → 0.2.49

package/lib/esm/index.js

@@ -1,5 +1,5 @@
 import { WebSocket } from 'ws';
-import { GraphBuilder } from '@bian-womp/spark-graph';
+import { GraphBuilder, createEngine } from '@bian-womp/spark-graph';
 
 class SeqGenerator {
     constructor() {
@@ -239,12 +239,14 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
     const registry = await createRegistry();
     const builder = new GraphBuilder(registry);
     let graphRuntime;
+    let engine;
     let extData = {};
     // Helper to get current context
     const getContext = () => ({
         registry,
         builder,
         graphRuntime,
+        engine,
         extData,
     });
     // Original implementations - define as separate functions first to allow cross-references
@@ -415,21 +417,81 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
             graphRuntime.setEnvironment(env);
         },
         setInput: (nodeId, handle, value) => {
-            graphRuntime?.setInput(nodeId, handle, value);
+            // If engine exists, use it; otherwise fall back to direct runtime access
+            if (engine) {
+                engine.setInput(nodeId, handle, value);
+            }
+            else {
+                graphRuntime?.setInput(nodeId, handle, value);
+            }
         },
         setInputs: (nodeId, inputs) => {
-            graphRuntime?.setInputs(nodeId, inputs);
+            if (engine) {
+                engine.setInputs(nodeId, inputs);
+            }
+            else {
+                graphRuntime?.setInputs(nodeId, inputs);
+            }
         },
         triggerExternal: (nodeId, event) => {
-            graphRuntime?.triggerExternal(nodeId, event);
+            if (engine) {
+                engine.triggerExternal(nodeId, event);
+            }
+            else {
+                graphRuntime?.triggerExternal(nodeId, event);
+            }
+        },
+        launch: (opts) => {
+            if (!graphRuntime) {
+                throw new Error("Cannot launch: graph runtime not built");
+            }
+            // Dispose existing engine if any
+            if (engine) {
+                engine.dispose();
+                engine = undefined;
+            }
+            // Create new engine using shared factory
+            engine = createEngine(graphRuntime, opts);
+            // Launch the engine
+            if (engine) {
+                engine.launch(opts?.invalidate);
+            }
+        },
+        step: async () => {
+            if (!engine)
+                return;
+            // Type guard for StepEngine
+            if ("step" in engine && typeof engine.step === "function") {
+                await engine.step();
+            }
+        },
+        computeNode: async (nodeId) => {
+            if (!engine)
+                return;
+            // Type guard for PullEngine
+            if ("computeNode" in engine && typeof engine.computeNode === "function") {
+                await engine.computeNode(nodeId);
+            }
         },
-        launch: (invalidate) => {
-            graphRuntime?.launch(invalidate);
+        flush: async () => {
+            if (!engine)
+                return;
+            // Type guard for BatchedEngine
+            if ("flush" in engine && typeof engine.flush === "function") {
+                await engine.flush();
+            }
         },
         whenIdle: () => {
+            if (engine) {
+                return engine.whenIdle();
+            }
             return graphRuntime?.whenIdle?.() ?? Promise.resolve();
         },
         dispose: () => {
+            if (engine) {
+                engine.dispose();
+                engine = undefined;
+            }
             graphRuntime?.dispose?.();
             graphRuntime = undefined;
         },
@@ -440,6 +502,10 @@ async function createRuntimeAdapter(createRegistry, send, extensions) {
         if (!extension) {
             return original;
         }
+        // Handle optional methods that might be undefined
+        if (!original) {
+            return original;
+        }
         return ((...args) => {
             return extension(original, getContext(), ...args);
         });
@@ -497,9 +563,12 @@ class RemoteEngine {
             this.emit("stats", msg.payload);
         }
     }
-    launch(invalidate) {
+    launch(invalidate, engineConfig) {
         this.transport.send({
-            message: { type: "Launch", payload: { invalidate } },
+            message: {
+                type: "Launch",
+                payload: { invalidate, ...engineConfig },
+            },
         });
     }
     setInput(nodeId, handle, value) {
@@ -643,6 +712,7 @@ class RuntimeApiClient {
         this.transportEventListeners = new Set();
         this.disposed = false;
         this.config = config;
+        this.runnerId = options?.runnerId;
         if (options?.onCustomEvent) {
             this.customEventListeners.add(options.onCustomEvent);
         }
@@ -691,8 +761,11 @@ class RuntimeApiClient {
         if (this.connectingPromise) {
             return this.connectingPromise;
         }
-        const kind = this.config.kind;
-        this.emitTransportStatus({ state: "connecting", kind });
+        this.emitTransportStatus({
+            state: "connecting",
+            kind: this.config.kind,
+            runnerId: this.runnerId,
+        });
         // Create connection promise to prevent concurrent connections
         this.connectingPromise = (async () => {
             try {
@@ -705,12 +778,20 @@ class RuntimeApiClient {
                 });
                 // Create engine with connected transport
                 this.engine = new RemoteEngine(transport);
-                this.emitTransportStatus({ state: "connected", kind });
+                this.emitTransportStatus({
+                    state: "connected",
+                    kind: this.config.kind,
+                    runnerId: this.runnerId,
+                });
             }
             catch (error) {
                 // Clear connecting promise on error so retry is possible
                 this.connectingPromise = undefined;
-                this.emitTransportStatus({ state: "disconnected", kind });
+                this.emitTransportStatus({
+                    state: "disconnected",
+                    kind: this.config.kind,
+                    runnerId: this.runnerId,
+                });
                 throw error;
             }
             finally {
@@ -731,7 +812,7 @@ class RuntimeApiClient {
         const type = msg.type;
         // Standard runtime events: stats, value, error, invalidate
         // These are handled by RemoteEngine via transport subscription
-        // Custom events are anything else (e.g., flow-opened, flow-latest)
+        // Custom events are anything else
         if (!["stats", "value", "error", "invalidate"].includes(type)) {
             // Emit to custom event listeners (constructor callback is auto-subscribed)
             for (const listener of this.customEventListeners) {
@@ -747,8 +828,11 @@ class RuntimeApiClient {
         this.transportEventListeners.add(listener);
         // Immediately emit current status if connected
         if (this.transport) {
-            const kind = this.config.kind;
-            listener({ state: "connected", kind });
+            listener({
+                state: "connected",
+                kind: this.config.kind,
+                runnerId: this.runnerId,
+            });
         }
         return () => {
             this.transportEventListeners.delete(listener);
@@ -869,6 +953,33 @@ class RuntimeApiClient {
         }
         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" },
+        });
+    }
     /**
      * Dispose the client and close the transport connection.
      * Idempotent: safe to call multiple times.
@@ -896,7 +1007,11 @@ class RuntimeApiClient {
         // Clear listeners
         this.customEventListeners.clear();
         this.transportEventListeners.clear();
-        this.emitTransportStatus({ state: "disconnected", kind: this.config.kind });
+        this.emitTransportStatus({
+            state: "disconnected",
+            kind: this.config.kind,
+            runnerId: this.runnerId,
+        });
     }
 }
 
@@ -1007,8 +1122,43 @@ class RuntimeApiServer {
                 break;
             }
             case "Launch": {
-                this.logCommand("Launch", env);
-                this.runtimeApi.launch(msg.payload.invalidate);
+                const launchPayload = msg.payload;
+                this.logCommand("Launch", env, {
+                    engine: launchPayload.engine,
+                    invalidate: launchPayload.invalidate,
+                });
+                this.runtimeApi.launch({
+                    invalidate: launchPayload.invalidate,
+                    engine: launchPayload.engine,
+                    batched: launchPayload.batched,
+                    hybrid: launchPayload.hybrid,
+                });
+                ack();
+                break;
+            }
+            case "Step": {
+                this.logCommand("Step", env);
+                if (this.runtimeApi.step) {
+                    await this.runtimeApi.step();
+                }
+                ack();
+                break;
+            }
+            case "ComputeNode": {
+                this.logCommand("ComputeNode", env, {
+                    nodeId: msg.payload.nodeId,
+                });
+                if (this.runtimeApi.computeNode) {
+                    await this.runtimeApi.computeNode(msg.payload.nodeId);
+                }
+                ack();
+                break;
+            }
+            case "Flush": {
+                this.logCommand("Flush", env);
+                if (this.runtimeApi.flush) {
+                    await this.runtimeApi.flush();
+                }
                 ack();
                 break;
             }