@bian-womp/spark-workbench 0.3.78 → 0.3.80

package/lib/cjs/index.cjs

@@ -1425,10 +1425,7 @@ class LocalGraphRunner extends AbstractGraphRunner {
         const snapshot = await this.snapshotFull();
         const converter = sparkGraph.buildValueConverter(converterConfig);
         const converted = sparkGraph.convertSnapshot(snapshot, converter);
-        await this.applySnapshotFull(converted, {
-            skipBuild: true,
-            dry: options?.dry,
-        });
+        await this.applySnapshotFull(converted, { skipBuild: true, dry: options?.dry });
         return converted;
     }
     async pause() {
@@ -1506,139 +1503,101 @@ class RemoteGraphRunner extends AbstractGraphRunner {
     getCacheKey(nodeId, handle, io) {
         return `${nodeId}.${io}.${handle}`;
     }
-    /**
-     * Fetch full registry description from remote and register it locally.
-     * Simplified with straightforward retry loop.
-     * Ensures only one fetch happens at a time, even with concurrent calls.
-     */
-    async fetchRegistry(client) {
-        if (this.registryFetched) {
-            return;
-        }
-        // If already fetching, wait for that fetch to complete
-        if (this.registryFetchPromise) {
-            return this.registryFetchPromise;
-        }
-        // Create promise wrapper and assign atomically to prevent race conditions
-        // This ensures concurrent calls will see the promise and wait for it
-        let promise;
-        this.registryFetchPromise = promise = (async () => {
-            try {
-                await this._doFetchRegistry(client);
+    applyRegistryDescriptor(desc) {
+        for (const t of desc.types) {
+            if (t.options) {
+                this.registry.registerEnum({
+                    id: t.id,
+                    options: t.options,
+                    bakeTarget: t.bakeTarget,
+                });
             }
-            finally {
-                // Clear the promise after completion (success or failure)
-                this.registryFetchPromise = undefined;
+            else if (!this.registry.types.has(t.id)) {
+                this.registry.registerType({
+                    id: t.id,
+                    displayName: t.displayName,
+                    validate: (_v) => true,
+                    bakeTarget: t.bakeTarget,
+                });
             }
-        })();
-        return promise;
-    }
-    /**
-     * Internal method that performs the actual registry fetch.
-     */
-    async _doFetchRegistry(client) {
-        let lastError;
-        for (let attempt = 1; attempt <= this.MAX_REGISTRY_FETCH_ATTEMPTS; attempt++) {
-            try {
-                // Add timeout to registry fetch - if it exceeds 3s, retry
-                let timeoutId;
-                const timeoutPromise = new Promise((_, reject) => {
-                    timeoutId = setTimeout(() => reject(new Error("Registry fetch timeout (3s exceeded)")), this.REGISTRY_FETCH_TIMEOUT_MS);
+        }
+        for (const c of desc.categories || []) {
+            if (!this.registry.categories.has(c.id)) {
+                const category = {
+                    id: c.id,
+                    displayName: c.displayName,
+                    createRuntime: () => ({
+                        async onInputsChanged() { },
+                    }),
+                    policy: { asyncConcurrency: "switch" },
+                };
+                this.registry.categories.register(category);
+            }
+        }
+        for (const c of desc.coercions) {
+            if (c.async) {
+                this.registry.registerAsyncCoercion(c.from, c.to, async (v) => v, {
+                    nonTransitive: c.nonTransitive,
                 });
-                const fetchPromise = client.api.describeRegistry().finally(() => {
-                    // Clear timeout if request completes first
-                    if (timeoutId) {
-                        clearTimeout(timeoutId);
-                        timeoutId = undefined;
-                    }
+            }
+            else {
+                this.registry.registerCoercion(c.from, c.to, (v) => v, {
+                    nonTransitive: c.nonTransitive,
                 });
-                const desc = await Promise.race([fetchPromise, timeoutPromise]);
-                // Register types
-                for (const t of desc.types) {
-                    if (t.options) {
-                        this.registry.registerEnum({
-                            id: t.id,
-                            options: t.options,
-                            bakeTarget: t.bakeTarget,
-                        });
-                    }
-                    else {
-                        if (!this.registry.types.has(t.id)) {
-                            this.registry.registerType({
-                                id: t.id,
-                                displayName: t.displayName,
-                                validate: (_v) => true,
-                                bakeTarget: t.bakeTarget,
-                            });
-                        }
-                    }
-                }
-                // Register categories
-                for (const c of desc.categories || []) {
-                    if (!this.registry.categories.has(c.id)) {
-                        // Create placeholder category descriptor
-                        const category = {
-                            id: c.id,
-                            displayName: c.displayName,
-                            createRuntime: () => ({
-                                async onInputsChanged() { },
-                            }),
-                            policy: { asyncConcurrency: "switch" },
-                        };
-                        this.registry.categories.register(category);
-                    }
-                }
-                // Register coercions
-                for (const c of desc.coercions) {
-                    if (c.async) {
-                        this.registry.registerAsyncCoercion(c.from, c.to, async (v) => v, {
-                            nonTransitive: c.nonTransitive,
-                        });
-                    }
-                    else {
-                        this.registry.registerCoercion(c.from, c.to, (v) => v, {
-                            nonTransitive: c.nonTransitive,
-                        });
-                    }
-                }
-                // Register nodes
-                for (const n of desc.nodes) {
-                    if (!this.registry.nodes.has(n.id)) {
-                        this.registry.registerNode({
-                            id: n.id,
-                            categoryId: n.categoryId,
-                            displayName: n.displayName,
-                            inputs: n.inputs || {},
-                            outputs: n.outputs || {},
-                            policy: n.policy || {},
-                            impl: () => { },
-                        });
-                    }
-                }
-                this.registryFetched = true;
-                this.emit("registry", this.registry);
-                return;
             }
-            catch (err) {
-                lastError = err instanceof Error ? err : new Error(String(err));
-                if (attempt < this.MAX_REGISTRY_FETCH_ATTEMPTS) {
-                    const delayMs = this.INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
-                    console.warn(`Failed to fetch registry (attempt ${attempt}/${this.MAX_REGISTRY_FETCH_ATTEMPTS}), retrying in ${delayMs}ms...`, lastError);
-                    // Wait before retrying
-                    await new Promise((resolve) => setTimeout(resolve, delayMs));
-                }
+        }
+        for (const n of desc.nodes) {
+            if (!this.registry.nodes.has(n.id)) {
+                this.registry.registerNode({
+                    id: n.id,
+                    categoryId: n.categoryId,
+                    displayName: n.displayName,
+                    inputs: n.inputs || {},
+                    outputs: n.outputs || {},
+                    policy: n.policy || {},
+                    impl: () => { },
+                });
             }
         }
-        // Max attempts reached, emit final error and throw
-        console.error(`Failed to fetch registry after ${this.MAX_REGISTRY_FETCH_ATTEMPTS} attempts:`, lastError);
-        this.emit("error", {
-            kind: "registry",
-            message: `Failed to fetch registry after ${this.MAX_REGISTRY_FETCH_ATTEMPTS} attempts. Please check your connection and try refreshing.`,
-            err: lastError,
-            attempt: this.MAX_REGISTRY_FETCH_ATTEMPTS,
-            maxAttempts: this.MAX_REGISTRY_FETCH_ATTEMPTS,
+        this.registryFetched = true;
+        if (this.registryBootstrapResolve) {
+            this.registryBootstrapResolve();
+            this.registryBootstrapResolve = undefined;
+            this.registryBootstrapReject = undefined;
+        }
+        this.emit("registry", this.registry);
+    }
+    isRecord(value) {
+        return typeof value === "object" && value !== null;
+    }
+    isRegistryDescriptorEvent(message) {
+        if (!this.isRecord(message))
+            return false;
+        if (message.type !== "registry-descriptor")
+            return false;
+        if (!this.isRecord(message.payload))
+            return false;
+        return "registry" in message.payload;
+    }
+    waitForRegistryBootstrap() {
+        if (this.registryFetched)
+            return Promise.resolve();
+        if (this.registryBootstrapPromise)
+            return this.registryBootstrapPromise;
+        this.registryBootstrapPromise = new Promise((resolve, reject) => {
+            this.registryBootstrapResolve = resolve;
+            this.registryBootstrapReject = reject;
+            setTimeout(() => {
+                if (!this.registryFetched && this.registryBootstrapReject) {
+                    this.registryBootstrapReject(new Error(`Registry bootstrap timeout (${this.REGISTRY_BOOTSTRAP_TIMEOUT_MS}ms exceeded)`));
+                    this.registryBootstrapResolve = undefined;
+                    this.registryBootstrapReject = undefined;
+                }
+            }, this.REGISTRY_BOOTSTRAP_TIMEOUT_MS);
+        }).finally(() => {
+            this.registryBootstrapPromise = undefined;
         });
-        throw lastError;
+        return this.registryBootstrapPromise;
     }
     /**
      * Build RemoteRuntimeClient config from RemoteExecutionBackend config.
@@ -1700,13 +1659,27 @@ class RemoteGraphRunner extends AbstractGraphRunner {
             const clientConfig = this.buildClientConfig(backend);
             // Wrap custom event handler to intercept viewport events and emit viewport event
             const wrappedOnCustomEvent = (event) => {
-                const msg = event?.message;
-                if (msg && typeof msg === "object" && "type" in msg && msg.type === "viewport") {
-                    const viewport = msg.payload?.viewport;
+                const msg = event.message;
+                if (this.isRecord(msg) && msg.type === "viewport" && this.isRecord(msg.payload)) {
+                    const viewport = msg.payload.viewport;
                     if (isValidViewport(viewport)) {
                         this.emit("viewport", { viewport });
                     }
                 }
+                else if (this.isRecord(msg) && msg.type === "flow-opened" && this.isRecord(msg.payload)) {
+                    const sessionId = msg.payload.sessionId;
+                    const resumed = msg.payload.resumed;
+                    if (typeof sessionId === "number") {
+                        console.info(`[RemoteGraphRunner] Flow opened (runner=${this.runnerId}, sessionId=${sessionId}, resumed=${Boolean(resumed)})`);
+                    }
+                }
+                else if (this.isRecord(msg) && msg.type === "flow-closed" && this.isRecord(msg.payload)) {
+                    const reason = msg.payload.reason;
+                    console.warn(`[RemoteGraphRunner] Flow closed (runner=${this.runnerId}, reason=${typeof reason === "string" ? reason : "unknown"})`);
+                }
+                else if (this.isRegistryDescriptorEvent(msg)) {
+                    this.applyRegistryDescriptor(msg.payload.registry);
+                }
                 // Call original handler if provided
                 if (backend.onCustomEvent) {
                     backend.onCustomEvent(event);
@@ -1724,12 +1697,11 @@ class RemoteGraphRunner extends AbstractGraphRunner {
             this.client = client;
             this.valueCache.clear();
             this.listenersBound = false;
-            // Fetch registry before returning (wait for it to complete)
-            // Only fetch if not already fetched (handles concurrent calls)
+            // Wait for registry descriptor pushed by backend on flow-open.
             if (!this.registryFetched) {
-                console.info("[RemoteGraphRunner] Loading registry from remote...");
-                await this.fetchRegistry(client);
-                console.info("[RemoteGraphRunner] Loaded registry from remote");
+                console.info("[RemoteGraphRunner] Waiting for registry bootstrap event...");
+                await this.waitForRegistryBootstrap();
+                console.info("[RemoteGraphRunner] Received registry bootstrap event");
             }
             // Clear promise on success
             this.clientPromise = undefined;
@@ -1743,9 +1715,7 @@ class RemoteGraphRunner extends AbstractGraphRunner {
         this.valueCache = new Map();
         this.listenersBound = false;
         this.registryFetched = false;
-        this.MAX_REGISTRY_FETCH_ATTEMPTS = 3;
-        this.INITIAL_RETRY_DELAY_MS = 1000; // 1 second
-        this.REGISTRY_FETCH_TIMEOUT_MS = 3000; // 3 seconds
+        this.REGISTRY_BOOTSTRAP_TIMEOUT_MS = 15000; // 15 seconds
         // Generate readable ID for this runner instance (e.g., remote-001, remote-002)
         remoteRunnerCounter++;
         this.runnerId = `remote-${String(remoteRunnerCounter).padStart(3, "0")}`;
@@ -2032,9 +2002,7 @@ class RemoteGraphRunner extends AbstractGraphRunner {
         this.hydrateValueCache(payload, { dry: options?.dry });
         // Then sync with backend
         const client = await this.ensureClient();
-        await client.api.applySnapshotFull(payload, {
-            skipBuild: options?.skipBuild,
-        });
+        await client.api.applySnapshotFull(payload, { skipBuild: options?.skipBuild });
     }
     async convertSnapshot(converterConfig, options) {
         const client = await this.ensureClient();