From 2f09cd2188f4b298a0c8847ce5eefccee22e09d1 Mon Sep 17 00:00:00 2001 From: "claude[bot]" <209825114+claude[bot]@users.noreply.github.com> Date: Thu, 24 Sep 2026 00:01:57 +0000 Subject: [PATCH 1/2] fix: subgraph-interior widgets don't render in Vue mode after insert_workflow (#18634) ## Summary Fixes missing Vue widgets on nodes inside a subgraph inserted through `insert_workflow`. Multiplayer assigns inserted nodes colon-bearing local IDs. Those IDs cannot be represented safely as colon-delimited locator or execution paths, so widget rendering now resolves live nodes from the existing `(graphId, nodeId)` state instead. ## Changes - Resolve widget hosts directly within their owning graph without parsing the local node ID. - Continue rendering and updating stored widgets when no valid execution ID exists, while skipping execution-keyed error operations. - Prevent `LGraph.getNodeById` from returning inherited object properties. - Cover the real insert/projection/widget-model path, the pre-graph-ready fallback, scope collisions, and inherited registry keys. ## Verification - `pnpm exec vitest run src/lib/litegraph/src/LGraph.test.ts src/utils/graphTraversalUtil.test.ts src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts` (280 passed) - `pnpm typecheck:app` - ESLint, type-aware oxlint, formatting, and Knip passed on the changed files. --------- Co-authored-by: Claude Co-authored-by: Amp --- src/lib/litegraph/src/LGraph.test.ts | 7 + src/lib/litegraph/src/LGraph.ts | 4 +- ...SubgraphInteriorWidgets.regression.test.ts | 170 ++++++++++++++++++ .../composables/processedWidgetRenderModel.ts | 54 +++--- .../composables/useProcessedWidgets.test.ts | 31 ++++ .../composables/useProcessedWidgets.ts | 8 +- src/utils/graphTraversalUtil.test.ts | 22 +++ src/utils/graphTraversalUtil.ts | 11 ++ 8 files changed, 273 insertions(+), 34 deletions(-) create mode 100644 src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts diff --git a/src/lib/litegraph/src/LGraph.test.ts b/src/lib/litegraph/src/LGraph.test.ts index eea4ddc8179..56ad6996577 100644 --- a/src/lib/litegraph/src/LGraph.test.ts +++ b/src/lib/litegraph/src/LGraph.test.ts @@ -334,6 +334,13 @@ describe('LGraph', () => { expect(graph.last_node_id).toBe(7) }) + it.for(['constructor', 'toString', '__proto__'])( + 'does not return inherited property %s as a node', + (id) => { + expect(new LGraph().getNodeById(toNodeId(id))).toBeNull() + } + ) + describe('duplicate node-instance invariants', () => { function createGraphsSharingANodeId() { const ownerGraph = new LGraph() diff --git a/src/lib/litegraph/src/LGraph.ts b/src/lib/litegraph/src/LGraph.ts index 0c2eecd38b3..59b59e43c7a 100644 --- a/src/lib/litegraph/src/LGraph.ts +++ b/src/lib/litegraph/src/LGraph.ts @@ -1609,7 +1609,9 @@ export class LGraph * Returns a node by its id. */ getNodeById(id: NodeId | null | undefined): LGraphNode | null { - return id != null && id !== UNASSIGNED_NODE_ID + return id != null && + id !== UNASSIGNED_NODE_ID && + Object.hasOwn(this._nodes_by_id, id) ? (this._nodes_by_id[id] ?? null) : null } diff --git a/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts b/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts new file mode 100644 index 00000000000..d63675d5ce1 --- /dev/null +++ b/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts @@ -0,0 +1,170 @@ +import { applyOps, mint } from '@comfyorg/comfy-multi-player' +import type { + InsertWorkflowOp, + WidgetCatalog +} from '@comfyorg/comfy-multi-player' +import { assert, beforeEach, expect, it, onTestFinished } from 'vitest' +import * as Y from 'yjs' + +import { + LGraph, + LGraphNode, + LiteGraph, + SubgraphNode +} from '@/lib/litegraph/src/litegraph' +import { + createTestSubgraph, + createTestSubgraphNode, + enableSubgraphNodeCreation +} from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' +import { + stripGraphPrefix, + useWidgetValueStore +} from '@/stores/widgetValueStore' +import { graphScopeOf } from '@/types/graphScopeId' +import { toNodeId } from '@/types/nodeId' +import { inertPlacementPort } from '@/workbench/extensions/agent/crdt/__fixtures__/inertPlacementPort' +import { AgentCrdtProjection } from '@/workbench/extensions/agent/crdt/agentCrdtProjection' +import { FollowerDoc } from '@/workbench/extensions/agent/crdt/followerDoc' +import { createGraphMutations } from '@/workbench/extensions/agent/crdt/graphMutations' + +import type { WidgetUiCallbacks } from './processedWidgetRenderModel' +import { computeProcessedWidgets } from './useProcessedWidgets' + +class InteriorWidgetNode extends LGraphNode { + constructor() { + super('interior-widget') + this.serialize_widgets = true + this.addWidget('text', 'prompt', 'before insert', () => {}) + } +} + +const catalog: WidgetCatalog = { + types: { + 'interior-widget': { widget_order: ['prompt'] } + } +} + +const noopUi: WidgetUiCallbacks = { + getTooltipConfig: () => ({}), + handleNodeRightClick: () => {} +} + +beforeEach(() => { + LiteGraph.registerNodeType('interior-widget', InteriorWidgetNode) +}) + +function bindProjection(workflowId: string, graph: LGraph) { + const follower = new FollowerDoc() + const projection = new AgentCrdtProjection( + createGraphMutations({ + getScope: () => graphScopeOf(graph), + layout: { createNode: () => {}, deleteNodes: () => {} }, + placement: inertPlacementPort + }), + () => graph, + () => follower.doc + ) + projection.bind(workflowId, follower) + onTestFinished(() => { + projection.destroy() + follower.destroy() + }) + + let sequence = 0 + return (update: Uint8Array, opIds: string[]) => { + follower.applyRemoteUpdate(update) + const committed = projection.applyFrame({ + workflowId, + seq: ++sequence, + update, + actor: 'agent:test', + opIds + }) + projection.reconcileLiveGraph(workflowId) + return committed + } +} + +function serializeWorkflow(graph: LGraph): InsertWorkflowOp['workflow'] { + return JSON.parse( + JSON.stringify(graph.serialize()) + ) as InsertWorkflowOp['workflow'] +} + +it('produces a live Vue widget model for an inserted subgraph-interior node', () => { + const graph = new LGraph() + onTestFinished(enableSubgraphNodeCreation(graph)) + + const blueprint = new LGraph() + const subgraph = createTestSubgraph({ rootGraph: blueprint }) + blueprint.subgraphs.set(subgraph.id, subgraph) + + const interior = LiteGraph.createNode('interior-widget') + assert(interior) + interior.id = toNodeId(42) + subgraph.add(interior) + assert(interior.widgets?.[0]) + interior.widgets[0].value = 'after insert' + blueprint.add(createTestSubgraphNode(subgraph, { id: 1 })) + + const hostDoc = mint({ nodes: [], links: [] }, catalog) + onTestFinished(() => hostDoc.destroy()) + const deliver = bindProjection('inserted-subgraph-widget', graph) + deliver(Y.encodeStateAsUpdate(hostDoc), []) + + const operation: InsertWorkflowOp = { + op_id: 'inserted-subgraph-widget-test-0001', + actor: 'agent:test', + base_version: 1, + stamp: [1, 'agent:test'], + op: 'insert_workflow', + workflow: serializeWorkflow(blueprint) + } + const vector = Y.encodeStateVector(hostDoc) + expect(applyOps(hostDoc, [operation], catalog).outcomes).toEqual([ + { op_id: operation.op_id, outcome: 'applied' } + ]) + expect( + deliver(Y.encodeStateAsUpdate(hostDoc, vector), [operation.op_id]) + ).toBe(true) + + const instance = graph._nodes.find( + (node): node is SubgraphNode => node instanceof SubgraphNode + ) + assert(instance) + const materialized = instance.subgraph._nodes.find( + (node) => node.type === 'interior-widget' + ) + assert(materialized) + expect(String(materialized.id)).toContain(':') + + const rootGraphId = graph.rootGraph.id + const localNodeId = stripGraphPrefix(String(materialized.id)) + assert(localNodeId) + const widgetIds = useWidgetValueStore().getNodeWidgetIds( + rootGraphId, + localNodeId + ) + const processed = computeProcessedWidgets({ + nodeData: materialized._state, + widgetIds, + graphId: rootGraphId, + showAdvanced: false, + isGraphReady: true, + rootGraph: graph, + ui: noopUi + }) + + expect( + processed.map(({ visible, simplified }) => ({ + name: simplified.name, + value: simplified.value, + visible + })) + ).toEqual([{ name: 'prompt', value: 'after insert', visible: true }]) + + assert(processed[0]) + processed[0].updateHandler('updated through Vue') + expect(materialized.widgets?.[0]?.value).toBe('updated through Vue') +}) diff --git a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts index 5798a02c550..7daaf8049d1 100644 --- a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts +++ b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts @@ -30,8 +30,8 @@ import { useWidgetValueStore } from '@/stores/widgetValueStore' import { - createLeafNodeExecutionId, - createLeafNodeLocatorId + createNodeExecutionId, + createNodeLocatorId } from '@/types/nodeIdentification' import type { NodeExecutionId, NodeLocatorId } from '@/types/nodeIdentification' import type { NodeId } from '@/types/nodeId' @@ -47,8 +47,7 @@ import type { WidgetId } from '@/types/widgetId' import { executionIdFromState, executionIdToNodeLocatorId, - getNodeByLocatorId, - locatorIdFromState, + getNodeByState, subgraphIdFromState } from '@/utils/graphTraversalUtil' import { mapLiveWidgetsById } from '@/utils/litegraphUtil' @@ -155,8 +154,7 @@ function getHostNode( nodeData: NodeState ): LGraphNode | null { if (!rootGraph) return null - const locatorId = locatorIdFromState(nodeData, rootGraph.id) - return locatorId ? getNodeByLocatorId(rootGraph, locatorId) : null + return getNodeByState(rootGraph, nodeData) } function isWidgetVisible( @@ -171,7 +169,7 @@ function isWidgetVisible( function hasWidgetError( widget: { name: string; errorTarget?: WidgetErrorTarget }, - nodeExecId: NodeExecutionId, + nodeExecId: NodeExecutionId | null, nodeErrors: | { errors: { extra_info?: { input_name?: string } }[] } | undefined, @@ -183,8 +181,9 @@ function hasWidgetError( !!nodeErrors?.errors.some( (e) => e.extra_info?.input_name === widget.name ) || - missingModelStore.isWidgetMissingModel(nodeExecId, widget.name) || - missingMediaStore.isWidgetMissingMedia(nodeExecId, widget.name) + (nodeExecId !== null && + (missingModelStore.isWidgetMissingModel(nodeExecId, widget.name) || + missingMediaStore.isWidgetMissingMedia(nodeExecId, widget.name))) const target = widget.errorTarget if (!target) return hasHostError @@ -214,7 +213,7 @@ function createWidgetUpdateHandler({ id: WidgetId live?: { node: LGraphNode; widget: IBaseWidget } errorTarget?: WidgetErrorTarget - nodeExecId: NodeExecutionId + nodeExecId: NodeExecutionId | null widgetName: string widgetOptions: IWidgetOptions executionErrorStore: ReturnType @@ -239,13 +238,15 @@ function createWidgetUpdateHandler({ options ) } - executionErrorStore.clearWidgetRelatedErrors( - nodeExecId, - widgetName, - widgetName, - newValue, - options - ) + if (nodeExecId) { + executionErrorStore.clearWidgetRelatedErrors( + nodeExecId, + widgetName, + widgetName, + newValue, + options + ) + } } } @@ -323,12 +324,10 @@ function widgetNodeLocatorId( ) if (sourceLocator) return sourceLocator } - if (!bareWidgetId) return undefined - return ( - createLeafNodeLocatorId( - subgraphIdFromState(ctx.nodeData, ctx.rootGraphId), - bareWidgetId - ) ?? undefined + if (!bareWidgetId || bareWidgetId.includes(':')) return undefined + return createNodeLocatorId( + subgraphIdFromState(ctx.nodeData, ctx.rootGraphId), + bareWidgetId ) } @@ -341,7 +340,7 @@ interface WidgetProcessingContext { hostNode: LGraphNode | null liveWidgets: Map slotMetadata: Map - nodeExecId: NodeExecutionId + nodeExecId: NodeExecutionId | null nodeErrors: Parameters[2] widgetValueStore: ReturnType executionErrorStore: ReturnType @@ -473,8 +472,7 @@ export function computeProcessedWidgets({ const nodeExecId = isGraphReady && rootGraph ? executionIdFromState(rootGraph, nodeData) - : createLeafNodeExecutionId(nodeData.id) - if (!nodeExecId) return [] + : createNodeExecutionId([nodeData.id]) const hostNode = getHostNode(rootGraph, nodeData) const liveWidgets = hostNode @@ -506,7 +504,9 @@ export function computeProcessedWidgets({ liveWidgets, slotMetadata, nodeExecId, - nodeErrors: executionErrorStore.lastNodeErrors?.[nodeExecId], + nodeErrors: nodeExecId + ? executionErrorStore.lastNodeErrors?.[nodeExecId] + : undefined, widgetValueStore, executionErrorStore, missingModelStore, diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts index c0bdc39c7ba..f5ea8f0275e 100644 --- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts +++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts @@ -11,6 +11,7 @@ import { } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' import type { SubgraphNode } from '@/lib/litegraph/src/subgraph/SubgraphNode' import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets' +import { useMissingMediaStore } from '@/platform/missingMedia/missingMediaStore' import { useMissingModelStore } from '@/platform/missingModel/missingModelStore' import { computeProcessedWidgets } from '@/renderer/extensions/vueNodes/composables/useProcessedWidgets' import WidgetDOM from '@/renderer/extensions/vueNodes/widgets/components/WidgetDOM.vue' @@ -401,6 +402,36 @@ describe('promoted subgraph widgets', () => { }) describe('computeProcessedWidgets', () => { + it('renders an opaque-ID widget before its graph is ready', () => { + const nodeId = toNodeId('insert:abc123:root:node:5') + const id = widgetId(GRAPH_ID, nodeId, 'text') + registerWidgetState(id, { type: 'text', value: 'before' }) + const missingModelSpy = vi.spyOn( + useMissingModelStore(), + 'isWidgetMissingModel' + ) + const missingMediaSpy = vi.spyOn( + useMissingMediaStore(), + 'isWidgetMissingMedia' + ) + const clearErrorSpy = vi.spyOn( + useExecutionErrorStore(), + 'clearWidgetRelatedErrors' + ) + + const [processed] = processWidgets({ widgetIds: [id], nodeId }) + + expect(processed.simplified.value).toBe('before') + expect(processed.hasError).toBe(false) + expect(missingModelSpy).not.toHaveBeenCalled() + expect(missingMediaSpy).not.toHaveBeenCalled() + + processed.updateHandler('after') + + expect(useWidgetValueStore().getWidget(id)?.value).toBe('after') + expect(clearErrorSpy).not.toHaveBeenCalled() + }) + it('applies advanced border styling to advanced widgets', () => { const id = widgetId(GRAPH_ID, toNodeId(1), 'text') registerWidgetState(id, { type: 'text', options: { advanced: true } }) diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts index 8a50c9c8a4a..b519bad54a8 100644 --- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts +++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts @@ -17,18 +17,14 @@ import { app } from '@/scripts/app' import { nodeTypeValidForApp } from '@/stores/appModeStore' import type { NodeState } from '@/types/nodeState' import type { WidgetId } from '@/types/widgetId' -import { - getNodeByLocatorId, - locatorIdFromState -} from '@/utils/graphTraversalUtil' +import { getNodeByState } from '@/utils/graphTraversalUtil' export { computeProcessedWidgets } export type { ProcessedWidget } function getHostNode(nodeData: NodeState): LGraphNode | null { if (!app.isGraphReady) return null - const locatorId = locatorIdFromState(nodeData, app.rootGraph.id) - return locatorId ? getNodeByLocatorId(app.rootGraph, locatorId) : null + return getNodeByState(app.rootGraph, nodeData) } export function useProcessedWidgets( diff --git a/src/utils/graphTraversalUtil.test.ts b/src/utils/graphTraversalUtil.test.ts index d9111785110..dbe5cf2f7e4 100644 --- a/src/utils/graphTraversalUtil.test.ts +++ b/src/utils/graphTraversalUtil.test.ts @@ -18,6 +18,7 @@ import { getLocalNodeIdFromExecutionId, getNodeByExecutionId, getNodeByLocatorId, + getNodeByState, getRootGraph, getSubgraphPathFromExecutionId, executionIdFromState, @@ -1100,6 +1101,27 @@ describe('graphTraversalUtil', () => { }) }) + describe('getNodeByState', () => { + it('uses graph identity to disambiguate colon-bearing node IDs', () => { + const subgraphUuid = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890' + const nodeId = toNodeId(`${subgraphUuid}:node:5`) + const rootNode = createMockNode(nodeId) + const interiorNode = createMockNode(nodeId) + const subgraph = createMockSubgraph(subgraphUuid, [interiorNode]) + const graph = createMockGraph([ + rootNode, + createMockNode('456', { isSubgraph: true, subgraph }) + ]) + + expect( + getNodeByState(graph, { id: nodeId, graphId: ROOT_GRAPH_ID }) + ).toBe(rootNode) + expect( + getNodeByState(graph, { id: nodeId, graphId: subgraphUuid }) + ).toBe(interiorNode) + }) + }) + describe('getNodeByLocatorId', () => { it('should find node in root graph', () => { const nodes = [createMockNode('123'), createMockNode('456')] diff --git a/src/utils/graphTraversalUtil.ts b/src/utils/graphTraversalUtil.ts index ca84ff75002..474f044c802 100644 --- a/src/utils/graphTraversalUtil.ts +++ b/src/utils/graphTraversalUtil.ts @@ -633,6 +633,17 @@ export function executionIdFromState( return getExecutionIdByNode(rootGraph, node) ?? fallback } +export function getNodeByState( + rootGraph: LGraph, + state: Pick +): LGraphNode | null { + const graph = + state.graphId === rootGraph.id + ? rootGraph + : findSubgraphByUuid(rootGraph, state.graphId) + return graph?.getNodeById(state.id) ?? null +} + /** * Get a node by its locator ID from anywhere in the graph hierarchy. * For subgraph nodes, the format is `:` where From 4a448833f0ba4f2177303604a120c88d9b3c3f28 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 24 Sep 2026 00:45:07 +0000 Subject: [PATCH 2/2] fix: drop backport-only test that references a main-only crdt module src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts (added by the #18634 backport) imports AgentCrdtProjection from @/workbench/extensions/agent/crdt/agentCrdtProjection. That module only exists on main; this release branch's crdt subsystem still uses the older EcsFollowerAdapter design that predates the AgentCrdtProjection refactor, so the import fails to resolve here. This broke typecheck (validate-fonts, e2e build/setup), lint (import-x/no-unresolved in lint-and-format), and therefore the e2e Playwright deployment (merge-reports/e2e-status had nothing to merge because the build never got that far). The runtime fix in this PR (LGraph.ts, graphTraversalUtil.ts, processedWidgetRenderModel.ts, useProcessedWidgets.ts and their existing test files) does not depend on this test. Equivalent subgraph-interior insert_workflow regression coverage already exists on this branch via agentSubgraphInsertWorkflow.regression.test.ts and agentInsertWorkflowWidgets.regression.test.ts, so dropping this one test file is safe. --- ...SubgraphInteriorWidgets.regression.test.ts | 170 ------------------ 1 file changed, 170 deletions(-) delete mode 100644 src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts diff --git a/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts b/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts deleted file mode 100644 index d63675d5ce1..00000000000 --- a/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts +++ /dev/null @@ -1,170 +0,0 @@ -import { applyOps, mint } from '@comfyorg/comfy-multi-player' -import type { - InsertWorkflowOp, - WidgetCatalog -} from '@comfyorg/comfy-multi-player' -import { assert, beforeEach, expect, it, onTestFinished } from 'vitest' -import * as Y from 'yjs' - -import { - LGraph, - LGraphNode, - LiteGraph, - SubgraphNode -} from '@/lib/litegraph/src/litegraph' -import { - createTestSubgraph, - createTestSubgraphNode, - enableSubgraphNodeCreation -} from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' -import { - stripGraphPrefix, - useWidgetValueStore -} from '@/stores/widgetValueStore' -import { graphScopeOf } from '@/types/graphScopeId' -import { toNodeId } from '@/types/nodeId' -import { inertPlacementPort } from '@/workbench/extensions/agent/crdt/__fixtures__/inertPlacementPort' -import { AgentCrdtProjection } from '@/workbench/extensions/agent/crdt/agentCrdtProjection' -import { FollowerDoc } from '@/workbench/extensions/agent/crdt/followerDoc' -import { createGraphMutations } from '@/workbench/extensions/agent/crdt/graphMutations' - -import type { WidgetUiCallbacks } from './processedWidgetRenderModel' -import { computeProcessedWidgets } from './useProcessedWidgets' - -class InteriorWidgetNode extends LGraphNode { - constructor() { - super('interior-widget') - this.serialize_widgets = true - this.addWidget('text', 'prompt', 'before insert', () => {}) - } -} - -const catalog: WidgetCatalog = { - types: { - 'interior-widget': { widget_order: ['prompt'] } - } -} - -const noopUi: WidgetUiCallbacks = { - getTooltipConfig: () => ({}), - handleNodeRightClick: () => {} -} - -beforeEach(() => { - LiteGraph.registerNodeType('interior-widget', InteriorWidgetNode) -}) - -function bindProjection(workflowId: string, graph: LGraph) { - const follower = new FollowerDoc() - const projection = new AgentCrdtProjection( - createGraphMutations({ - getScope: () => graphScopeOf(graph), - layout: { createNode: () => {}, deleteNodes: () => {} }, - placement: inertPlacementPort - }), - () => graph, - () => follower.doc - ) - projection.bind(workflowId, follower) - onTestFinished(() => { - projection.destroy() - follower.destroy() - }) - - let sequence = 0 - return (update: Uint8Array, opIds: string[]) => { - follower.applyRemoteUpdate(update) - const committed = projection.applyFrame({ - workflowId, - seq: ++sequence, - update, - actor: 'agent:test', - opIds - }) - projection.reconcileLiveGraph(workflowId) - return committed - } -} - -function serializeWorkflow(graph: LGraph): InsertWorkflowOp['workflow'] { - return JSON.parse( - JSON.stringify(graph.serialize()) - ) as InsertWorkflowOp['workflow'] -} - -it('produces a live Vue widget model for an inserted subgraph-interior node', () => { - const graph = new LGraph() - onTestFinished(enableSubgraphNodeCreation(graph)) - - const blueprint = new LGraph() - const subgraph = createTestSubgraph({ rootGraph: blueprint }) - blueprint.subgraphs.set(subgraph.id, subgraph) - - const interior = LiteGraph.createNode('interior-widget') - assert(interior) - interior.id = toNodeId(42) - subgraph.add(interior) - assert(interior.widgets?.[0]) - interior.widgets[0].value = 'after insert' - blueprint.add(createTestSubgraphNode(subgraph, { id: 1 })) - - const hostDoc = mint({ nodes: [], links: [] }, catalog) - onTestFinished(() => hostDoc.destroy()) - const deliver = bindProjection('inserted-subgraph-widget', graph) - deliver(Y.encodeStateAsUpdate(hostDoc), []) - - const operation: InsertWorkflowOp = { - op_id: 'inserted-subgraph-widget-test-0001', - actor: 'agent:test', - base_version: 1, - stamp: [1, 'agent:test'], - op: 'insert_workflow', - workflow: serializeWorkflow(blueprint) - } - const vector = Y.encodeStateVector(hostDoc) - expect(applyOps(hostDoc, [operation], catalog).outcomes).toEqual([ - { op_id: operation.op_id, outcome: 'applied' } - ]) - expect( - deliver(Y.encodeStateAsUpdate(hostDoc, vector), [operation.op_id]) - ).toBe(true) - - const instance = graph._nodes.find( - (node): node is SubgraphNode => node instanceof SubgraphNode - ) - assert(instance) - const materialized = instance.subgraph._nodes.find( - (node) => node.type === 'interior-widget' - ) - assert(materialized) - expect(String(materialized.id)).toContain(':') - - const rootGraphId = graph.rootGraph.id - const localNodeId = stripGraphPrefix(String(materialized.id)) - assert(localNodeId) - const widgetIds = useWidgetValueStore().getNodeWidgetIds( - rootGraphId, - localNodeId - ) - const processed = computeProcessedWidgets({ - nodeData: materialized._state, - widgetIds, - graphId: rootGraphId, - showAdvanced: false, - isGraphReady: true, - rootGraph: graph, - ui: noopUi - }) - - expect( - processed.map(({ visible, simplified }) => ({ - name: simplified.name, - value: simplified.value, - visible - })) - ).toEqual([{ name: 'prompt', value: 'after insert', visible: true }]) - - assert(processed[0]) - processed[0].updateHandler('updated through Vue') - expect(materialized.widgets?.[0]?.value).toBe('updated through Vue') -})