@bian-womp/spark-workbench 0.3.90 → 0.3.91

package/lib/src/runtime/RemoteGraphRunner.js

@@ -1,696 +0,0 @@
-import { RemoteRuntimeClient, } from "@bian-womp/spark-remote";
-import { AbstractGraphRunner } from "./AbstractGraphRunner";
-import { isValidViewport } from "../misc/viewport-utils";
-// Counter for generating readable runner IDs
-let remoteRunnerCounter = 0;
-export class RemoteGraphRunner extends AbstractGraphRunner {
-    /**
-     * Generate cache key that includes io type to prevent collisions
-     * between input and output handles with the same name
-     */
-    getCacheKey(nodeId, handle, io) {
-        return `${nodeId}.${io}.${handle}`;
-    }
-    applyRegistryDescriptor(desc) {
-        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,
-                });
-            }
-        }
-        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,
-                });
-            }
-            else {
-                this.registry.registerCoercion(c.from, c.to, (v) => v, {
-                    nonTransitive: c.nonTransitive,
-                });
-            }
-        }
-        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;
-        if (this.registryBootstrapResolve) {
-            this.registryBootstrapResolve();
-            this.registryBootstrapResolve = undefined;
-            this.registryBootstrapReject = undefined;
-        }
-        this.emit("registry", this.registry);
-    }
-    isRecord(value) {
-        return typeof value === "object" && value !== null;
-    }
-    isRegistryEvent(message) {
-        if (!this.isRecord(message))
-            return false;
-        if (message.type !== "registry")
-            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;
-        });
-        return this.registryBootstrapPromise;
-    }
-    /**
-     * Build RemoteRuntimeClient config from RemoteExecutionBackend config.
-     */
-    buildClientConfig(backend) {
-        if (backend.kind === "remote-http") {
-            return {
-                kind: "remote-http",
-                baseUrl: backend.baseUrl,
-                connectOptions: backend.connectOptions,
-            };
-        }
-        else {
-            return {
-                kind: "remote-ws",
-                url: backend.url,
-                connectOptions: backend.connectOptions,
-            };
-        }
-    }
-    /**
-     * Setup event subscriptions for the client.
-     */
-    setupClientSubscriptions(client) {
-        // Subscribe to transport status changes
-        // Convert RemoteRuntimeClient.TransportStatus to IGraphRunner.TransportStatus
-        // Only emit status if it matches this runner's ID
-        this.transportStatusUnsubscribe = client.onTransportStatus((status) => {
-            if (status.runnerId && status.runnerId !== this.runnerId)
-                return;
-            // Map remote-unix to undefined since RemoteGraphRunner doesn't support it
-            const mappedKind = status.kind === "remote-unix" ? undefined : status.kind;
-            const transportStatus = {
-                state: status.state,
-                kind: mappedKind,
-                runnerId: this.runnerId,
-            };
-            // Track current status
-            this.currentTransportStatus = transportStatus;
-            this.emit("transport", transportStatus);
-        });
-    }
-    // Ensure remote client
-    async ensureClient() {
-        if (this.disposed) {
-            throw new Error("Cannot ensure client: RemoteGraphRunner has been disposed");
-        }
-        if (this.client)
-            return this.client;
-        // If already connecting, wait for that connection to complete
-        if (this.clientPromise)
-            return this.clientPromise;
-        const backend = this.backend;
-        // Create connection promise to prevent concurrent connections
-        // Create promise wrapper first, then assign immediately before async work starts
-        let promise;
-        this.clientPromise = promise = (async () => {
-            // Build client config from backend config
-            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 (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.isRegistryEvent(msg)) {
-                    this.applyRegistryDescriptor(msg.payload.registry);
-                }
-                // Call original handler if provided
-                if (backend.onCustomEvent) {
-                    backend.onCustomEvent(event);
-                }
-            };
-            // Create client with wrapped custom event handler
-            const client = new RemoteRuntimeClient(clientConfig, {
-                onCustomEvent: wrappedOnCustomEvent,
-                runnerId: this.runnerId,
-            });
-            // Setup event subscriptions
-            this.setupClientSubscriptions(client);
-            // Connect the client (this will create and connect transport)
-            await client.connect();
-            this.client = client;
-            this.valueCache.clear();
-            this.listenersBound = false;
-            // Wait for registry runtime event pushed by backend on flow-open.
-            if (!this.registryFetched) {
-                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;
-            return client;
-        })();
-        return promise;
-    }
-    constructor(backend) {
-        super(backend);
-        this.disposed = false;
-        this.valueCache = new Map();
-        this.listenersBound = false;
-        this.registryFetched = false;
-        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")}`;
-        console.info(`[RemoteGraphRunner] Created runner with ID: ${this.runnerId}`);
-        // Initialize transport status as "connecting" - will be updated when connection completes
-        this.currentTransportStatus = {
-            state: "connecting",
-            kind: backend.kind,
-        };
-        // Auto-handle registry-changed invalidations from remote
-        // We listen on invalidate and if reason matches, we rehydrate registry and emit a registry event
-        this.ensureClient().then(async (client) => {
-            const eng = client.engine;
-            if (!this.listenersBound) {
-                eng.on("invalidate", async (e) => {
-                    if (e.reason === "registry-changed") {
-                        try {
-                            const deltas = Array.isArray(e.deltas) ? e.deltas : [];
-                            for (const d of deltas) {
-                                if (!d || typeof d !== "object")
-                                    continue;
-                                if (d.kind === "register-enum") {
-                                    this.registry.registerEnum({
-                                        id: d.id,
-                                        displayName: d.displayName,
-                                        options: d.options,
-                                        opts: d.opts,
-                                        bakeTarget: d.bakeTarget,
-                                    });
-                                }
-                                else if (d.kind === "register-type") {
-                                    if (!this.registry.types.has(d.id)) {
-                                        this.registry.registerType({
-                                            id: d.id,
-                                            displayName: d.displayName,
-                                            validate: (_v) => true,
-                                            bakeTarget: d.bakeTarget,
-                                        });
-                                    }
-                                }
-                                else if (d.kind === "register-node") {
-                                    if (!this.registry.nodes.has(d.desc?.id)) {
-                                        this.registry.registerNode({
-                                            id: String(d.desc?.id || ""),
-                                            categoryId: String(d.desc?.categoryId || "compute"),
-                                            displayName: d.desc?.displayName,
-                                            inputs: d.desc?.inputs || {},
-                                            outputs: d.desc?.outputs || {},
-                                            impl: () => { },
-                                        });
-                                    }
-                                }
-                            }
-                            this.emit("registry", this.registry);
-                            // Trigger update so validation/UI refreshes using last known graph
-                            try {
-                                if (this.lastDef)
-                                    await this.update(this.lastDef);
-                            }
-                            catch {
-                                console.error("Failed to update graph definition after registry changed");
-                            }
-                        }
-                        catch {
-                            console.error("Failed to handle registry changed event");
-                        }
-                    }
-                });
-            }
-        });
-    }
-    build(def) { }
-    async update(def, options) {
-        // Remote: forward update and await completion
-        const client = await this.ensureClient();
-        try {
-            await client.api.update(def, options);
-            this.emit("invalidate", { reason: "graph-updated" });
-            this.lastDef = def;
-        }
-        catch (err) {
-            // Log error but don't throw to maintain compatibility
-            console.error("[RemoteGraphRunner] Error updating graph:", err);
-        }
-    }
-    launch(def, opts) {
-        if (this.engine) {
-            this.engine.dispose();
-            this.engine = undefined;
-        }
-        // Remote: build remotely then launch
-        this.ensureClient().then(async (client) => {
-            await client.api.build(def);
-            // Signal UI after remote build as well
-            this.emit("invalidate", { reason: "graph-built" });
-            this.lastDef = def;
-            // Hydrate current remote inputs/outputs (including defaults) into cache
-            try {
-                const snap = await client.api.snapshot();
-                for (const [nodeId, map] of Object.entries(snap.inputs || {})) {
-                    for (const [handle, value] of Object.entries(map || {})) {
-                        this.valueCache.set(this.getCacheKey(nodeId, handle, "input"), {
-                            value,
-                        });
-                        this.emit("value", { nodeId, handle, value, io: "input" });
-                    }
-                }
-                for (const [nodeId, map] of Object.entries(snap.outputs || {})) {
-                    for (const [handle, value] of Object.entries(map || {})) {
-                        this.valueCache.set(this.getCacheKey(nodeId, handle, "output"), {
-                            value,
-                        });
-                        this.emit("value", { nodeId, handle, value, io: "output" });
-                    }
-                }
-            }
-            catch {
-                console.error("Failed to hydrate remote inputs/outputs");
-            }
-            await this.createAndLaunchEngine(opts);
-        });
-    }
-    async createAndLaunchEngine(opts) {
-        const client = await this.ensureClient();
-        // Configure and launch engine on the backend
-        await client.api.launch(opts);
-        // Get the remote engine proxy and wire up event listeners
-        const eng = client.engine;
-        if (!this.listenersBound) {
-            eng.on("value", (e) => {
-                this.valueCache.set(this.getCacheKey(e.nodeId, e.handle, e.io), {
-                    value: e.value,
-                    runtimeTypeId: e.runtimeTypeId,
-                });
-                this.emit("value", e);
-            });
-            eng.on("error", (e) => this.emit("error", e));
-            eng.on("invalidate", (e) => this.emit("invalidate", e));
-            eng.on("stats", (e) => this.emit("stats", e));
-            this.listenersBound = true;
-        }
-        this.engine = eng;
-        const runMode = opts?.runMode ?? "manual";
-        this.emit("status", { running: true, runMode });
-        // Re-apply staged inputs using client.setInputs for consistency
-        for (const [nodeId, map] of Object.entries(this.stagedInputs)) {
-            await eng.setInputs(nodeId, map, undefined).catch(() => {
-                // Ignore errors during launch - inputs will be set when user calls setInputs
-            });
-        }
-    }
-    /**
-     * Launch using an existing backend runtime that has already been built and hydrated.
-     * This is used when resuming from a snapshot where the backend has already applied
-     * ApplySnapshotFull (which builds the graph and hydrates inputs/outputs).
-     * Unlike launch(), this method does NOT call client.build() to avoid destroying
-     * the runtime state that was just restored.
-     */
-    launchExisting(def, opts) {
-        if (this.engine) {
-            this.engine.dispose();
-            this.engine = undefined;
-        }
-        // Remote: attach to existing runtime and launch (do NOT rebuild)
-        this.ensureClient().then(async (client) => {
-            // NOTE: We do NOT call client.build(def) here because the backend runtime
-            // has already been built and hydrated via ApplySnapshotFull.
-            // Calling build() would create a new runtime and lose the restored state.
-            this.lastDef = def;
-            await this.createAndLaunchEngine(opts);
-        });
-    }
-    setRunMode(runMode) {
-        if (this.engine) {
-            this.engine.setRunMode(runMode);
-            this.emit("status", { running: true, runMode });
-        }
-    }
-    async computeNode(nodeId) {
-        const client = await this.ensureClient();
-        await client.engine.computeNode(nodeId);
-    }
-    async runFromHere(nodeId) {
-        const client = await this.ensureClient();
-        await client.engine.runFromHere(nodeId);
-    }
-    async cancelNodeRuns(nodeIds) {
-        const client = await this.ensureClient();
-        await client.engine.cancelNodeRuns(nodeIds);
-    }
-    async setInputs(nodeId, inputs, options) {
-        // Update staged inputs (for getInputs to work correctly)
-        if (!this.stagedInputs[nodeId])
-            this.stagedInputs[nodeId] = {};
-        for (const [handle, value] of Object.entries(inputs)) {
-            if (value === undefined) {
-                delete this.stagedInputs[nodeId][handle];
-            }
-            else {
-                this.stagedInputs[nodeId][handle] = value;
-            }
-        }
-        try {
-            const client = await this.ensureClient();
-            await client.engine.setInputs(nodeId, inputs, options);
-        }
-        catch (err) {
-            // Emit synthetic events if connection fails
-            for (const [handle, value] of Object.entries(inputs)) {
-                this.emit("value", { nodeId, handle, value, io: "input" });
-            }
-            throw err;
-        }
-    }
-    async copyOutputs(fromNodeId, toNodeId, options) {
-        const client = await this.ensureClient();
-        await client.engine.copyOutputs(fromNodeId, toNodeId, options);
-    }
-    async triggerExternal(nodeId, event, options) {
-        const client = await this.ensureClient();
-        await client.engine.triggerExternal(nodeId, event, options);
-    }
-    async setViewport(viewport) {
-        const client = await this.ensureClient();
-        await client.api.setViewport(viewport);
-    }
-    async coerce(from, to, value) {
-        const client = await this.ensureClient();
-        try {
-            return await client.api.coerce(from, to, value);
-        }
-        catch {
-            return value;
-        }
-    }
-    async setExtData(data) {
-        const client = await this.ensureClient();
-        await client.api.setExtData(data);
-    }
-    async updateExtData(updates) {
-        const client = await this.ensureClient();
-        return await client.api.updateExtData(updates);
-    }
-    async commit(reason) {
-        const client = await this.ensureClient();
-        try {
-            const history = await client.api.commit(reason);
-            return history;
-        }
-        catch (err) {
-            console.error("[RemoteGraphRunner] Error committing:", err);
-            throw err;
-        }
-    }
-    async undo() {
-        const client = await this.ensureClient();
-        try {
-            return await client.api.undo();
-        }
-        catch {
-            return false;
-        }
-    }
-    async redo() {
-        const client = await this.ensureClient();
-        try {
-            return await client.api.redo();
-        }
-        catch {
-            return false;
-        }
-    }
-    async snapshotFull() {
-        const client = await this.ensureClient();
-        try {
-            return await client.api.snapshotFull();
-        }
-        catch {
-            return { inputs: {}, outputs: {} };
-        }
-    }
-    async applySnapshotFull(payload, options) {
-        // Hydrate local cache first so UI can display values immediately
-        this.hydrateValueCache(payload, { dry: options?.dry });
-        // Then sync with backend
-        const client = await this.ensureClient();
-        await client.api.applySnapshotFull(payload, { skipBuild: options?.skipBuild });
-    }
-    async convertSnapshot(converterConfig, options) {
-        const client = await this.ensureClient();
-        const converted = await client.api.convertSnapshot(converterConfig, {
-            dry: options?.dry,
-        });
-        // Hydrate local cache with converted values
-        this.hydrateValueCache(converted, { dry: options?.dry });
-        return converted;
-    }
-    async pause() {
-        const client = await this.ensureClient();
-        await client.api.pause();
-    }
-    async resume() {
-        const client = await this.ensureClient();
-        await client.api.resume();
-    }
-    /**
-     * Hydrates the local valueCache from a snapshot and emits value events.
-     * This ensures the UI can display inputs/outputs immediately without waiting
-     * for value events from the remote backend.
-     */
-    hydrateValueCache(snapshot, opts) {
-        // Hydrate inputs
-        for (const [nodeId, map] of Object.entries(snapshot.inputs || {})) {
-            for (const [handle, value] of Object.entries(map || {})) {
-                this.valueCache.set(this.getCacheKey(nodeId, handle, "input"), {
-                    value,
-                });
-                this.emit("value", {
-                    nodeId,
-                    handle,
-                    value,
-                    io: "input",
-                    dry: opts?.dry,
-                });
-            }
-        }
-        // Hydrate outputs
-        for (const [nodeId, map] of Object.entries(snapshot.outputs || {})) {
-            for (const [handle, value] of Object.entries(map || {})) {
-                this.valueCache.set(this.getCacheKey(nodeId, handle, "output"), {
-                    value,
-                });
-                this.emit("value", {
-                    nodeId,
-                    handle,
-                    value,
-                    io: "output",
-                    dry: opts?.dry,
-                });
-            }
-        }
-    }
-    async setEnvironment(env, opts) {
-        // Use client if available, otherwise ensure client and then set environment
-        if (this.client) {
-            await this.client.api.setEnvironment(env, opts);
-        }
-        else {
-            try {
-                const client = await this.ensureClient();
-                await client.api.setEnvironment(env, opts);
-            }
-            catch {
-                // Silently fail if connection not available
-            }
-        }
-    }
-    getEnvironment() {
-        // Interface requires sync return, but RemoteRuntimeClient.getEnvironment() is async.
-        // Returns undefined synchronously; callers needing the actual value should:
-        // - Use snapshotFull() which includes environment
-        // - Call client.getEnvironment() directly if they have access to the client
-        // This is a limitation of the sync interface signature.
-        return undefined;
-    }
-    getOutputs(def) {
-        const out = {};
-        const cache = this.valueCache;
-        if (!cache)
-            return out;
-        for (const n of def.nodes) {
-            const resolved = n.resolvedHandles?.outputs;
-            const desc = this.registry.nodes.get(n.typeId);
-            const handles = Object.keys(resolved ?? desc?.outputs ?? {});
-            for (const h of handles) {
-                const key = this.getCacheKey(n.nodeId, h, "output");
-                const rec = cache.get(key);
-                if (rec) {
-                    if (!out[n.nodeId])
-                        out[n.nodeId] = {};
-                    out[n.nodeId][h] = rec.value;
-                }
-            }
-        }
-        return out;
-    }
-    getInputs(def) {
-        const out = {};
-        const cache = this.valueCache;
-        const inputPrefix = ".input.";
-        for (const n of def.nodes) {
-            const staged = this.stagedInputs[n.nodeId] ?? {};
-            const cur = {};
-            // Include ALL input values from cache (not just resolved/desc handles).
-            // Dynamic nodes (e.g. ext.scene.area) have geo handles that may not be in
-            // resolvedHandles yet; we must return every user-set value for duplication.
-            const prefix = `${n.nodeId}${inputPrefix}`;
-            for (const [key, rec] of cache.entries()) {
-                if (key.startsWith(prefix)) {
-                    const handle = key.slice(prefix.length);
-                    cur[handle] = rec.value;
-                }
-            }
-            // Build inbound handle set for this node to honor wiring precedence
-            const inbound = new Set(def.edges.filter((e) => e.target.nodeId === n.nodeId).map((e) => e.target.handle));
-            // Merge staged only for non-inbound handles so UI doesn't override runtime values
-            const merged = { ...cur };
-            for (const [h, v] of Object.entries(staged)) {
-                if (!inbound.has(h))
-                    merged[h] = v;
-            }
-            if (Object.keys(merged).length > 0)
-                out[n.nodeId] = merged;
-        }
-        return out;
-    }
-    async dispose() {
-        // Idempotent: allow multiple calls safely
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        console.info(`[RemoteGraphRunner] Disposing runner with ID: ${this.runnerId}`);
-        super.dispose();
-        // Clear client promise if any
-        this.clientPromise = undefined;
-        // Unsubscribe from transport status
-        // Note: Custom events are cleaned up automatically when client is disposed
-        if (this.transportStatusUnsubscribe) {
-            this.transportStatusUnsubscribe();
-            this.transportStatusUnsubscribe = undefined;
-        }
-        // Dispose client (which will close transport)
-        const clientToDispose = this.client;
-        this.client = undefined;
-        this.registryFetched = false; // Reset so registry is fetched again on reconnect
-        if (clientToDispose) {
-            try {
-                await clientToDispose.dispose();
-            }
-            catch (err) {
-                console.warn("[RemoteGraphRunner] Error disposing client:", err);
-            }
-        }
-        const disconnectedStatus = {
-            state: "disconnected",
-            kind: this.backend.kind,
-            runnerId: this.runnerId,
-        };
-        this.currentTransportStatus = disconnectedStatus;
-        this.emit("transport", disconnectedStatus);
-    }
-    /**
-     * Override on() to emit current transport status immediately when a new listener subscribes.
-     * This ensures listeners don't miss the current status when they attach after connection.
-     */
-    on(event, handler) {
-        const unsubscribe = super.on(event, handler);
-        // If subscribing to transport events and we have a current status, emit it immediately
-        if (event === "transport" && this.currentTransportStatus) {
-            // Use setTimeout to ensure this happens after the listener is registered
-            // This prevents issues if the handler modifies state synchronously
-            setTimeout(() => {
-                // Type assertion is safe here because we checked event === "transport"
-                handler(this.currentTransportStatus);
-            }, 0);
-        }
-        return unsubscribe;
-    }
-}
-//# sourceMappingURL=RemoteGraphRunner.js.map