@artflo-ai/artflo-openclaw-plugin 0.0.1

package/dist/src/core/executor/execute-plan.js

@@ -0,0 +1,1221 @@
+import { randomUUID } from 'node:crypto';
+import { CANVAS_NODE_TYPES, buildEdgeElement, buildNodeElement } from './element-builders.js';
+import { calculateBatchGroupLayout, calculatePlanFlowLayout } from '../layout/layout-service.js';
+import { analyzePlanGroups } from '../plan/analyze-plan-groups.js';
+export async function executePlan(args) {
+    const { plan, session, traceWriter } = args;
+    const nodeMap = {};
+    const createdNodeIds = [];
+    const createdEdgeIds = [];
+    let executedNodeIds = [];
+    let executionCompleted = null;
+    const existingElements = session.getElements();
+    const existingNodeByRef = buildExistingNodeRefMap(existingElements, plan.planId);
+    const existingEdgeKeys = buildExistingEdgeKeySet(existingElements);
+    const explicitEdgeTargets = new Set(plan.edges.map((edge) => edge.to));
+    const groupAnalysis = analyzePlanGroups(plan);
+    await traceWriter?.writeMeta('input', {
+        plan,
+        existingElementCount: existingElements.length,
+        existingNodeRefs: Array.from(existingNodeByRef.keys()),
+    });
+    const refPositionMap = new Map();
+    const batchRefs = new Set(plan.nodes.filter((node) => node.type === 'batch').map((node) => node.ref));
+    // Defer nodes that transitively depend on a batch node.
+    // A batch node expands dynamically after its upstream (e.g. Refine) completes,
+    // so anything downstream of a batch must wait.
+    const deferredNodeRefs = new Set();
+    {
+        // Build adjacency: ref -> set of downstream refs
+        const downstreamOf = new Map();
+        for (const node of plan.nodes) {
+            downstreamOf.set(node.ref, new Set());
+        }
+        for (const edge of plan.edges) {
+            downstreamOf.get(edge.from)?.add(edge.to);
+        }
+        for (const node of plan.nodes) {
+            if (node.dependsOn && downstreamOf.has(node.dependsOn)) {
+                downstreamOf.get(node.dependsOn).add(node.ref);
+            }
+        }
+        // BFS from each batch ref to mark all transitive downstream as deferred
+        const queue = Array.from(batchRefs);
+        for (const batchRef of queue) {
+            deferredNodeRefs.add(batchRef);
+        }
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const children = downstreamOf.get(current);
+            if (!children)
+                continue;
+            for (const child of children) {
+                if (!deferredNodeRefs.has(child)) {
+                    deferredNodeRefs.add(child);
+                    queue.push(child);
+                }
+            }
+        }
+    }
+    const nonDeferredPlan = {
+        ...plan,
+        nodes: plan.nodes.filter((node) => !deferredNodeRefs.has(node.ref)),
+        edges: plan.edges.filter((edge) => !deferredNodeRefs.has(edge.from) && !deferredNodeRefs.has(edge.to)),
+    };
+    const flowLayout = calculatePlanFlowLayout({
+        plan: nonDeferredPlan,
+        canvasElements: existingElements,
+    });
+    for (const [ref, position] of flowLayout.positions.entries()) {
+        refPositionMap.set(ref, position);
+    }
+    await traceWriter?.writeRound('flow-layout', {
+        roots: flowLayout.roots,
+        subtreeHeights: flowLayout.subtreeHeights,
+        positions: Object.fromEntries(flowLayout.positions.entries()),
+    });
+    for (const batch of groupAnalysis.batches) {
+        const batchSourceSpec = plan.nodes.find((node) => node.ref === batch.sourceRef);
+        if (batchSourceSpec?.type !== 'batch') {
+            continue;
+        }
+        const batchSourceId = nodeMap[batch.sourceRef];
+        const groupSpecs = batch.groups.map((group) => ({
+            childCount: group.childRefs.length,
+            childType: group.childType,
+            layoutDirection: group.layoutDirection,
+        }));
+        if (groupSpecs.length === 0)
+            continue;
+        const batchLayout = calculateBatchGroupLayout(session.getElements(), batchSourceId, groupSpecs);
+        for (let groupIndex = 0; groupIndex < batch.groups.length; groupIndex += 1) {
+            const group = batch.groups[groupIndex];
+            const groupLayout = batchLayout.groups[groupIndex];
+            if (!groupLayout)
+                continue;
+            refPositionMap.set(group.headRef, groupLayout.inputPosition);
+            for (let childIndex = 0; childIndex < group.childRefs.length; childIndex += 1) {
+                if (groupLayout.childPositions[childIndex]) {
+                    refPositionMap.set(group.childRefs[childIndex], groupLayout.childPositions[childIndex]);
+                }
+            }
+        }
+    }
+    const materializedNodes = [];
+    for (const node of plan.nodes) {
+        if (deferredNodeRefs.has(node.ref)) {
+            continue;
+        }
+        const existingNodeId = existingNodeByRef.get(node.ref);
+        if (existingNodeId) {
+            nodeMap[node.ref] = existingNodeId;
+            const nextElement = buildNodeElement({
+                id: existingNodeId,
+                node,
+                sourceNodeId: node.dependsOn ? nodeMap[node.dependsOn] : undefined,
+                canvasElements: session.getElements(),
+                positionOverride: refPositionMap.get(node.ref),
+                planId: plan.planId,
+            });
+            await session.changeElements([
+                {
+                    id: existingNodeId,
+                    data: nextElement.data,
+                },
+            ]);
+            materializedNodes.push({
+                ref: node.ref,
+                id: existingNodeId,
+                type: node.type,
+                action: 'reused',
+            });
+            continue;
+        }
+        const nodeId = randomUUID().replace(/-/g, '');
+        nodeMap[node.ref] = nodeId;
+        const sourceNodeId = node.dependsOn ? nodeMap[node.dependsOn] : undefined;
+        const layoutInputElements = session.getElements();
+        const element = buildNodeElement({
+            id: nodeId,
+            node,
+            sourceNodeId,
+            canvasElements: layoutInputElements,
+            positionOverride: refPositionMap.get(node.ref),
+            planId: plan.planId,
+        });
+        await session.addElements([element]);
+        createdNodeIds.push(nodeId);
+        materializedNodes.push({
+            ref: node.ref,
+            id: nodeId,
+            type: node.type,
+            action: 'created',
+            position: element.position ?? null,
+            sourceNodeId: sourceNodeId ?? null,
+            layoutStrategy: element.__layoutDebug?.strategy ?? null,
+        });
+        if (node.type === 'input' &&
+            sourceNodeId &&
+            !explicitEdgeTargets.has(node.ref)) {
+            const implicitResult = await tryCreateImplicitInputSourceEdge(sourceNodeId, nodeId, session, existingEdgeKeys);
+            if (implicitResult.createdEdgeId) {
+                createdEdgeIds.push(implicitResult.createdEdgeId);
+            }
+            materializedNodes.push({
+                ref: node.ref,
+                id: nodeId,
+                action: 'implicit_source_to_input_edge',
+                edgeId: implicitResult.createdEdgeId ?? null,
+            });
+        }
+    }
+    await traceWriter?.writeRound('node-materialization', {
+        createdNodeIds,
+        nodeMap,
+        deferredNodeRefs: Array.from(deferredNodeRefs),
+        operations: materializedNodes,
+    });
+    // Backfill nodeMap for raw canvas element IDs referenced in edges.
+    // Agents may reference existing canvas elements by their raw ID (not a plan ref).
+    // Without this, tryCreateEdgeFromSpec cannot resolve sourceId/targetId.
+    {
+        const allElements = session.getElements();
+        const elementIdSet = new Set(allElements.map((el) => el.id));
+        for (const edge of plan.edges) {
+            for (const ref of [edge.from, edge.to]) {
+                if (!nodeMap[ref] && elementIdSet.has(ref)) {
+                    nodeMap[ref] = ref;
+                }
+            }
+        }
+    }
+    const edgeOperations = [];
+    for (const edge of plan.edges) {
+        if (deferredNodeRefs.has(edge.from) || deferredNodeRefs.has(edge.to)) {
+            continue;
+        }
+        if (shouldSkipRedundantProcessToProcessEdge(edge, plan)) {
+            edgeOperations.push({
+                ref: edge.ref || `${edge.from}-${edge.to}`,
+                action: 'skipped_redundant_process_edge',
+                from: edge.from,
+                to: edge.to,
+            });
+            continue;
+        }
+        const edgeResult = await tryCreateEdgeFromSpec({
+            edge,
+            plan,
+            nodeMap,
+            session,
+            existingEdgeKeys,
+        });
+        if (edgeResult.createdEdgeId) {
+            createdEdgeIds.push(edgeResult.createdEdgeId);
+            edgeOperations.push({
+                ref: edge.ref || `${edge.from}-${edge.to}`,
+                action: 'created',
+                edgeId: edgeResult.createdEdgeId,
+                from: edge.from,
+                to: edge.to,
+            });
+        }
+        else {
+            edgeOperations.push({
+                ref: edge.ref || `${edge.from}-${edge.to}`,
+                action: 'reused_or_skipped',
+                from: edge.from,
+                to: edge.to,
+            });
+        }
+    }
+    await traceWriter?.writeRound('explicit-edge-materialization', {
+        createdEdgeIds,
+        operations: edgeOperations,
+    });
+    const executableBatches = buildExecutableExecutionBatches(plan, plan.nodes
+        .filter((node) => isExecutableNodeType(node.type))
+        .map((node) => node.ref)
+        .filter((ref) => !batchRefs.has(ref)));
+    if (executableBatches.length > 0) {
+        executionCompleted = true;
+        for (const batch of executableBatches) {
+            const batchNodeIds = batch
+                .map((ref) => nodeMap[ref])
+                .filter((id) => Boolean(id));
+            await traceWriter?.writeRound('execute-batch-start', {
+                refs: batch,
+                nodeIds: batchNodeIds,
+            });
+            if (batchNodeIds.length === 0)
+                continue;
+            await session.executeNodes(batchNodeIds);
+            // Wait with retry: some nodes (e.g. Refine with logo_design) can take
+            // much longer than 5 minutes. Retry up to 3 times (total ~15 min).
+            let batchCompleted = false;
+            for (let attempt = 0; attempt < 3; attempt += 1) {
+                batchCompleted = await session.waitForCompletion(batchNodeIds, 300_000);
+                if (batchCompleted)
+                    break;
+                // Check if any node actually failed (status 400) vs still running
+                const allDone = batchNodeIds.every((id) => {
+                    const el = session.getElement(id);
+                    const status = el?.data?.status;
+                    return status === 3 || status === 400;
+                });
+                if (allDone) {
+                    batchCompleted = true;
+                    break;
+                }
+            }
+            executedNodeIds.push(...batchNodeIds);
+            if (!batchCompleted) {
+                executionCompleted = false;
+            }
+            await traceWriter?.writeRound('execute-batch-finish', {
+                refs: batch,
+                nodeIds: batchNodeIds,
+                completed: batchCompleted,
+                nodeStates: batchNodeIds.map((id) => ({
+                    id,
+                    data: session.getElement(id)?.data ?? null,
+                })),
+            });
+        }
+    }
+    const batchResults = await executeBatchNodes({
+        plan,
+        session,
+        nodeMap,
+        createdNodeIds,
+        createdEdgeIds,
+        existingNodeByRef,
+        existingEdgeKeys,
+        traceWriter,
+    });
+    if (batchResults.executedNodeIds.length > 0) {
+        executedNodeIds = [...executedNodeIds, ...batchResults.executedNodeIds];
+        executionCompleted =
+            executionCompleted === false || batchResults.executionCompleted === false
+                ? false
+                : executionCompleted === true || batchResults.executionCompleted === true
+                    ? true
+                    : executionCompleted;
+    }
+    return {
+        createdNodeIds,
+        createdEdgeIds,
+        nodeMap,
+        executedNodeIds,
+        executionCompleted,
+        traceDirectory: traceWriter?.directory,
+    };
+}
+function isExecutableNodeType(type) {
+    return type === 'process' || type === 'refine' || type === 'crop';
+}
+function buildExecutableExecutionBatches(plan, executableRefs) {
+    const uniqueExecutableRefs = Array.from(new Set(executableRefs));
+    if (uniqueExecutableRefs.length === 0) {
+        return [];
+    }
+    const nodeOrder = new Map();
+    plan.nodes.forEach((node, index) => nodeOrder.set(node.ref, index));
+    const incomingRefs = buildIncomingRefsMap(plan);
+    const executableRefSet = new Set(uniqueExecutableRefs);
+    const inDegree = new Map();
+    const dependents = new Map();
+    for (const ref of uniqueExecutableRefs) {
+        inDegree.set(ref, 0);
+        dependents.set(ref, new Set());
+    }
+    for (const ref of uniqueExecutableRefs) {
+        const upstreamExecutableRefs = collectUpstreamExecutableDependencies(ref, incomingRefs, executableRefSet);
+        inDegree.set(ref, upstreamExecutableRefs.size);
+        for (const dependencyRef of upstreamExecutableRefs) {
+            dependents.get(dependencyRef)?.add(ref);
+        }
+    }
+    const sortByPlanOrder = (refs) => refs.sort((a, b) => (nodeOrder.get(a) ?? Number.MAX_SAFE_INTEGER) -
+        (nodeOrder.get(b) ?? Number.MAX_SAFE_INTEGER));
+    let readyRefs = sortByPlanOrder(uniqueExecutableRefs.filter((ref) => (inDegree.get(ref) || 0) === 0));
+    const executedRefs = new Set();
+    const batches = [];
+    while (readyRefs.length > 0) {
+        const currentBatch = [...readyRefs];
+        batches.push(currentBatch);
+        readyRefs = [];
+        const nextReadyRefs = new Set();
+        for (const ref of currentBatch) {
+            executedRefs.add(ref);
+            const downstreamRefs = dependents.get(ref);
+            if (!downstreamRefs)
+                continue;
+            for (const downstreamRef of downstreamRefs) {
+                const nextInDegree = (inDegree.get(downstreamRef) || 0) - 1;
+                inDegree.set(downstreamRef, nextInDegree);
+                if (nextInDegree === 0 && !executedRefs.has(downstreamRef)) {
+                    nextReadyRefs.add(downstreamRef);
+                }
+            }
+        }
+        readyRefs = sortByPlanOrder(Array.from(nextReadyRefs));
+    }
+    if (executedRefs.size < uniqueExecutableRefs.length) {
+        const unresolvedRefs = sortByPlanOrder(uniqueExecutableRefs.filter((ref) => !executedRefs.has(ref)));
+        unresolvedRefs.forEach((ref) => batches.push([ref]));
+    }
+    return batches;
+}
+function buildIncomingRefsMap(plan) {
+    const incomingRefs = new Map();
+    for (const node of plan.nodes) {
+        incomingRefs.set(node.ref, new Set());
+    }
+    for (const edge of plan.edges) {
+        incomingRefs.get(edge.to)?.add(edge.from);
+    }
+    for (const node of plan.nodes) {
+        if (node.dependsOn) {
+            incomingRefs.get(node.ref)?.add(node.dependsOn);
+        }
+    }
+    return incomingRefs;
+}
+function collectUpstreamExecutableDependencies(targetRef, incomingRefs, executableRefSet) {
+    const dependencies = new Set();
+    const visitedRefs = new Set();
+    const queue = Array.from(incomingRefs.get(targetRef) || []);
+    while (queue.length > 0) {
+        const currentRef = queue.shift();
+        if (!currentRef || currentRef === targetRef || visitedRefs.has(currentRef)) {
+            continue;
+        }
+        visitedRefs.add(currentRef);
+        if (executableRefSet.has(currentRef)) {
+            dependencies.add(currentRef);
+            continue;
+        }
+        const parentRefs = incomingRefs.get(currentRef);
+        if (!parentRefs || parentRefs.size === 0)
+            continue;
+        for (const parentRef of parentRefs) {
+            if (!visitedRefs.has(parentRef)) {
+                queue.push(parentRef);
+            }
+        }
+    }
+    return dependencies;
+}
+async function executeBatchNodes(args) {
+    const { plan, session, nodeMap, createdNodeIds, createdEdgeIds, existingNodeByRef, existingEdgeKeys, traceWriter, } = args;
+    const executedNodeIds = [];
+    let executionCompleted = null;
+    const selectorRefs = new Set(plan.nodes
+        .filter((node) => node.type === 'selector')
+        .map((node) => node.ref));
+    for (const batchNode of plan.nodes.filter((node) => node.type === 'batch')) {
+        const sourceRef = batchNode.dependsOn;
+        if (!sourceRef) {
+            continue;
+        }
+        const sourceId = nodeMap[sourceRef];
+        const sourceElement = sourceId ? session.getElement(sourceId) : undefined;
+        if (!sourceId || !sourceElement) {
+            continue;
+        }
+        const outputs = extractBatchOutputs(sourceElement);
+        if (outputs.length === 0) {
+            await traceWriter?.writeRound('batch-no-outputs', {
+                batchRef: batchNode.ref,
+                sourceRef,
+                sourceId,
+            });
+            continue;
+        }
+        const downstreamEdge = plan.edges.find((edge) => edge.from === batchNode.ref);
+        const downstreamSelector = downstreamEdge && selectorRefs.has(downstreamEdge.to)
+            ? plan.nodes.find((node) => node.ref === downstreamEdge.to)
+            : undefined;
+        const models = Array.isArray(batchNode.data.models) && batchNode.data.models.length > 0
+            ? batchNode.data.models
+            : [{ model: batchNode.data.current_model || batchNode.data.model || 'default' }];
+        let selectorId;
+        const batchProcessIds = [];
+        await traceWriter?.writeRound('batch-prepare', {
+            batchRef: batchNode.ref,
+            sourceRef,
+            sourceId,
+            outputCount: outputs.length,
+            downstreamSelectorRef: downstreamSelector?.ref ?? null,
+            models,
+        });
+        // Pre-calculate layout positions for all batch-expanded nodes.
+        // Each output produces 1 input + N process nodes (one per model).
+        const batchPositionMap = new Map();
+        {
+            const groupSpecs = outputs.map(() => ({
+                childCount: models.length,
+                childType: 'process',
+                layoutDirection: 'horizontal',
+            }));
+            const batchLayout = calculateBatchGroupLayout(session.getElements(), sourceId, groupSpecs);
+            for (let outputIdx = 0; outputIdx < outputs.length; outputIdx += 1) {
+                const groupResult = batchLayout.groups[outputIdx];
+                if (!groupResult)
+                    continue;
+                const inputRef = `${batchNode.ref}_input_${outputs[outputIdx].index}`;
+                batchPositionMap.set(inputRef, groupResult.inputPosition);
+                let modelIdx = 0;
+                for (const modelSpec of models) {
+                    const processRef = typeof modelSpec === 'string'
+                        ? `${batchNode.ref}_process_${outputs[outputIdx].index}_${sanitizeRefFragment(modelSpec)}`
+                        : `${batchNode.ref}_process_${outputs[outputIdx].index}_${sanitizeRefFragment(modelSpec.model)}`;
+                    if (groupResult.childPositions[modelIdx]) {
+                        batchPositionMap.set(processRef, groupResult.childPositions[modelIdx]);
+                    }
+                    modelIdx += 1;
+                }
+            }
+        }
+        for (const output of outputs) {
+            const inputRef = `${batchNode.ref}_input_${output.index}`;
+            const existingInputId = existingNodeByRef.get(inputRef) ||
+                findExistingBatchInputId(session.getElements(), sourceId, output.index);
+            const inputId = existingInputId || randomUUID().replace(/-/g, '');
+            nodeMap[inputRef] = inputId;
+            const inputNode = buildNodeElement({
+                id: inputId,
+                node: {
+                    ref: inputRef,
+                    type: 'input',
+                    data: {
+                        prompt: output.prompt,
+                    },
+                    dependsOn: sourceRef,
+                },
+                sourceNodeId: sourceId,
+                canvasElements: session.getElements(),
+                planId: plan.planId,
+                positionOverride: batchPositionMap.get(inputRef),
+            });
+            if (existingInputId) {
+                await session.changeElements([{ id: inputId, data: inputNode.data }]);
+            }
+            else {
+                await session.addElements([inputNode]);
+                createdNodeIds.push(inputId);
+            }
+            const inputTarget = ensureInputTargetHandle(inputNode, sourceElement, sourceId, output.index);
+            await session.changeElements([inputTarget.change]);
+            const sourceToInput = await tryCreateEdgeFromSpec({
+                edge: {
+                    ref: `${batchNode.ref}:source:${output.index}`,
+                    from: sourceRef,
+                    to: inputRef,
+                    fromHandle: output.index,
+                    toHandle: inputTarget.handle,
+                },
+                plan,
+                nodeMap,
+                session,
+                existingEdgeKeys,
+            });
+            if (sourceToInput.createdEdgeId) {
+                createdEdgeIds.push(sourceToInput.createdEdgeId);
+            }
+            const existingProcessIds = findExistingBatchProcessIds(session.getElements(), inputId);
+            let modelIndex = 0;
+            for (const modelSpec of models) {
+                const processRef = typeof modelSpec === 'string'
+                    ? `${batchNode.ref}_process_${output.index}_${sanitizeRefFragment(modelSpec)}`
+                    : `${batchNode.ref}_process_${output.index}_${sanitizeRefFragment(modelSpec.model)}`;
+                const processId = existingNodeByRef.get(processRef) ||
+                    existingProcessIds[modelIndex] ||
+                    randomUUID().replace(/-/g, '');
+                nodeMap[processRef] = processId;
+                const processNode = buildNodeElement({
+                    id: processId,
+                    node: {
+                        ref: processRef,
+                        type: 'process',
+                        data: {
+                            ...batchNode.data,
+                            prompt: output.prompt,
+                            model: typeof modelSpec === 'string'
+                                ? modelSpec
+                                : modelSpec.model,
+                            current_model: typeof modelSpec === 'string'
+                                ? modelSpec
+                                : modelSpec.model,
+                            ratio: typeof modelSpec === 'object' && modelSpec.ratio
+                                ? modelSpec.ratio
+                                : batchNode.data.ratio,
+                            resolution: typeof modelSpec === 'object' && modelSpec.resolution
+                                ? modelSpec.resolution
+                                : batchNode.data.resolution,
+                            count: typeof modelSpec === 'object' && modelSpec.count
+                                ? modelSpec.count
+                                : batchNode.data.count,
+                        },
+                        dependsOn: inputRef,
+                    },
+                    sourceNodeId: inputId,
+                    canvasElements: session.getElements(),
+                    planId: plan.planId,
+                    positionOverride: batchPositionMap.get(processRef),
+                });
+                if (existingNodeByRef.has(processRef) || existingProcessIds[modelIndex]) {
+                    await session.changeElements([
+                        {
+                            id: processId,
+                            data: {
+                                ...processNode.data,
+                                status: 0,
+                                executed: false,
+                            },
+                        },
+                    ]);
+                }
+                else {
+                    await session.addElements([processNode]);
+                    createdNodeIds.push(processId);
+                }
+                batchProcessIds.push(processId);
+                const inputToProcess = await tryCreateEdgeFromSpec({
+                    edge: {
+                        ref: `${inputRef}->${processRef}`,
+                        from: inputRef,
+                        to: processRef,
+                    },
+                    plan,
+                    nodeMap,
+                    session,
+                    existingEdgeKeys,
+                });
+                if (inputToProcess.createdEdgeId) {
+                    createdEdgeIds.push(inputToProcess.createdEdgeId);
+                }
+                modelIndex += 1;
+            }
+            await traceWriter?.writeRound('batch-output-materialized', {
+                batchRef: batchNode.ref,
+                outputIndex: output.index,
+                inputRef,
+                inputId,
+                processIds: [...batchProcessIds],
+            });
+        }
+        if (batchProcessIds.length > 0) {
+            await traceWriter?.writeRound('batch-run-start', {
+                batchRef: batchNode.ref,
+                batchProcessIds,
+            });
+            await session.executeNodes(batchProcessIds);
+            let batchCompleted = false;
+            for (let attempt = 0; attempt < 3; attempt += 1) {
+                batchCompleted = await session.waitForCompletion(batchProcessIds, 300_000);
+                if (batchCompleted)
+                    break;
+                const allDone = batchProcessIds.every((id) => {
+                    const el = session.getElement(id);
+                    const status = el?.data?.status;
+                    return status === 3 || status === 400;
+                });
+                if (allDone) {
+                    batchCompleted = true;
+                    break;
+                }
+            }
+            executedNodeIds.push(...batchProcessIds);
+            executionCompleted =
+                executionCompleted === false || batchCompleted === false
+                    ? false
+                    : true;
+            await traceWriter?.writeRound('batch-run-finish', {
+                batchRef: batchNode.ref,
+                batchProcessIds,
+                completed: batchCompleted,
+                outputs: batchProcessIds.map((id) => ({
+                    id,
+                    medias: collectProcessOutputMedias(session.getElement(id)),
+                })),
+            });
+        }
+        if (selectorId === undefined && downstreamSelector && batchProcessIds.length > 0) {
+            // All batch processes are done — the Selector's upstream is now ready.
+            selectorId =
+                existingNodeByRef.get(downstreamSelector.ref) ||
+                    randomUUID().replace(/-/g, '');
+            nodeMap[downstreamSelector.ref] = selectorId;
+            // Position selector to the right of the rightmost batch process node
+            const batchProcessElements = batchProcessIds
+                .map((id) => session.getElement(id))
+                .filter((el) => el !== undefined);
+            const rightmostX = batchProcessElements.reduce((max, el) => {
+                const x = (el.position?.x ?? 0) + (el.measured?.width ?? 260);
+                return x > max ? x : max;
+            }, 0);
+            const avgY = batchProcessElements.length > 0
+                ? batchProcessElements.reduce((sum, el) => sum + (el.position?.y ?? 0), 0) /
+                    batchProcessElements.length
+                : 0;
+            const selectorElement = buildNodeElement({
+                id: selectorId,
+                node: downstreamSelector,
+                sourceNodeId: sourceId,
+                canvasElements: session.getElements(),
+                positionOverride: { x: rightmostX + 100, y: avgY },
+                planId: plan.planId,
+            });
+            if (existingNodeByRef.has(downstreamSelector.ref)) {
+                await session.changeElements([{ id: selectorId, data: selectorElement.data }]);
+            }
+            else {
+                await session.addElements([selectorElement]);
+                createdNodeIds.push(selectorId);
+            }
+        }
+        else if (downstreamSelector && nodeMap[downstreamSelector.ref]) {
+            selectorId = nodeMap[downstreamSelector.ref];
+        }
+        if (selectorId && batchProcessIds.length > 0) {
+            const selectorElement = session.getElement(selectorId);
+            if (selectorElement) {
+                for (const processId of batchProcessIds) {
+                    const processElement = session.getElement(processId);
+                    const outputMedias = collectProcessOutputMedias(processElement);
+                    // If process has real output medias, wire them
+                    if (outputMedias.length > 0) {
+                        for (const outputMedia of outputMedias) {
+                            const fromHandle = typeof outputMedia.id === 'string' ? outputMedia.id : undefined;
+                            const selectorTarget = ensureSelectorTargetHandle(selectorElement, processElement || selectorElement, processId, fromHandle);
+                            await session.changeElements([selectorTarget.change]);
+                            // Create edge directly from process to selector using real IDs
+                            const edgeId = randomUUID().replace(/-/g, '');
+                            const edgeKey = buildEdgeKey(processId, selectorId, fromHandle, selectorTarget.handle);
+                            if (!existingEdgeKeys.has(edgeKey)) {
+                                const edgeElement = buildEdgeElement({
+                                    id: edgeId,
+                                    edge: {
+                                        from: processId,
+                                        to: selectorId,
+                                        fromHandle,
+                                        toHandle: selectorTarget.handle,
+                                    },
+                                    sourceId: processId,
+                                    targetId: selectorId,
+                                });
+                                await session.addElements([edgeElement]);
+                                existingEdgeKeys.add(edgeKey);
+                                createdEdgeIds.push(edgeId);
+                            }
+                        }
+                    }
+                    else {
+                        // No real outputs yet — create placeholder handle
+                        const selectorTarget = ensureSelectorTargetHandle(selectorElement, processElement || selectorElement, processId, undefined);
+                        await session.changeElements([selectorTarget.change]);
+                        const edgeKey = buildEdgeKey(processId, selectorId, undefined, selectorTarget.handle);
+                        if (!existingEdgeKeys.has(edgeKey)) {
+                            const edgeId = randomUUID().replace(/-/g, '');
+                            const edgeElement = buildEdgeElement({
+                                id: edgeId,
+                                edge: {
+                                    from: processId,
+                                    to: selectorId,
+                                    toHandle: selectorTarget.handle,
+                                },
+                                sourceId: processId,
+                                targetId: selectorId,
+                            });
+                            await session.addElements([edgeElement]);
+                            existingEdgeKeys.add(edgeKey);
+                            createdEdgeIds.push(edgeId);
+                        }
+                    }
+                }
+            }
+            await traceWriter?.writeRound('batch-selector-updated', {
+                batchRef: batchNode.ref,
+                selectorId,
+                selectorState: session.getElement(selectorId)?.data ?? null,
+            });
+        }
+    }
+    return { executedNodeIds, executionCompleted };
+}
+function extractBatchOutputs(sourceElement) {
+    const sourceData = asRecord(sourceElement.data);
+    const multiOutputs = asRecord(sourceData.multi_outputs);
+    const outputKeys = Object.keys(multiOutputs).sort();
+    if (outputKeys.length > 0) {
+        return outputKeys.map((key) => {
+            const output = asRecord(multiOutputs[key]);
+            return {
+                index: key,
+                prompt: typeof output.prompt === 'string' ? output.prompt : '',
+            };
+        });
+    }
+    if (typeof sourceData.output_text === 'string' && sourceData.output_text.trim()) {
+        const separator = typeof sourceData.separator === 'string' && sourceData.separator
+            ? sourceData.separator
+            : '#@';
+        return sourceData.output_text
+            .split(separator)
+            .map((part) => part.trim())
+            .filter(Boolean)
+            .map((prompt, index) => ({
+            index: String(index),
+            prompt,
+        }));
+    }
+    return [];
+}
+function collectProcessOutputMedias(processElement) {
+    if (!processElement?.data) {
+        return [];
+    }
+    const processData = asRecord(processElement.data);
+    if (Array.isArray(processData.medias)) {
+        return processData.medias
+            .map((media) => asRecord(media))
+            .filter((media) => typeof media.url === 'string');
+    }
+    const medias = asRecord(processData.medias);
+    const values = Object.values(medias)
+        .map((media) => asRecord(media))
+        .filter((media) => typeof media.url === 'string');
+    if (values.length > 0) {
+        return values;
+    }
+    if (typeof processData.url === 'string' && processData.url) {
+        return [
+            {
+                id: processElement.id,
+                name: typeof processData.name === 'string' ? processData.name : 'image',
+                type: typeof processData.type === 'string' ? processData.type : 'image',
+                url: processData.url,
+                width: typeof processData.width === 'number' ? processData.width : 1024,
+                height: typeof processData.height === 'number' ? processData.height : 1024,
+            },
+        ];
+    }
+    return [];
+}
+function resolveDefaultSourceHandle(sourceElement) {
+    if (sourceElement.type === CANVAS_NODE_TYPES.PROCESS ||
+        sourceElement.type === CANVAS_NODE_TYPES.CROP ||
+        sourceElement.type === CANVAS_NODE_TYPES.IMAGE ||
+        sourceElement.type === CANVAS_NODE_TYPES.VIDEO ||
+        sourceElement.type === CANVAS_NODE_TYPES.RESULT) {
+        const media = resolveSourceMedia(sourceElement);
+        return typeof media?.id === 'string' ? media.id : undefined;
+    }
+    if (sourceElement.type === CANVAS_NODE_TYPES.REFINE) {
+        const sourceData = asRecord(sourceElement.data);
+        const outputs = asRecord(sourceData.multi_outputs);
+        const keys = Object.keys(outputs);
+        return keys.length > 0 ? keys[0] : undefined;
+    }
+    return undefined;
+}
+function normalizeSourceHandle(sourceElement, fromHandle) {
+    if (!fromHandle) {
+        return fromHandle;
+    }
+    if (sourceElement.type === CANVAS_NODE_TYPES.SELECTOR) {
+        return undefined;
+    }
+    return fromHandle;
+}
+function shouldSkipRedundantProcessToProcessEdge(edge, plan) {
+    const sourceNode = plan.nodes.find((node) => node.ref === edge.from);
+    const targetNode = plan.nodes.find((node) => node.ref === edge.to);
+    if (sourceNode?.type !== 'process' || targetNode?.type !== 'process') {
+        return false;
+    }
+    return plan.edges.some((firstHop) => {
+        if (firstHop.from !== edge.from || firstHop.to === edge.to) {
+            return false;
+        }
+        const middleNode = plan.nodes.find((node) => node.ref === firstHop.to);
+        if (middleNode?.type !== 'input') {
+            return false;
+        }
+        return plan.edges.some((secondHop) => secondHop.from === middleNode.ref && secondHop.to === edge.to);
+    });
+}
+async function tryCreateEdgeFromSpec(args) {
+    const { edge, nodeMap, session, existingEdgeKeys } = args;
+    const sourceId = nodeMap[edge.from];
+    const targetId = nodeMap[edge.to];
+    if (!sourceId || !targetId) {
+        return {};
+    }
+    const sourceElement = session.getElement(sourceId);
+    const targetElement = session.getElement(targetId);
+    if (!sourceElement || !targetElement) {
+        return {};
+    }
+    let fromHandle = normalizeSourceHandle(sourceElement, edge.fromHandle ?? resolveDefaultSourceHandle(sourceElement));
+    let toHandle = edge.toHandle;
+    let targetUpdateChange = null;
+    if (targetElement.type === CANVAS_NODE_TYPES.SELECTOR && !toHandle) {
+        const selectorTarget = ensureSelectorTargetHandle(targetElement, sourceElement, sourceId, fromHandle);
+        toHandle = selectorTarget.handle;
+        targetUpdateChange = selectorTarget.change;
+    }
+    if (targetElement.type === CANVAS_NODE_TYPES.INPUT && !toHandle) {
+        const inputTarget = ensureInputTargetHandle(targetElement, sourceElement, sourceId, fromHandle);
+        toHandle = inputTarget.handle;
+        targetUpdateChange = inputTarget.change;
+    }
+    const edgeKey = buildEdgeKey(sourceId, targetId, fromHandle, toHandle);
+    if (existingEdgeKeys.has(edgeKey)) {
+        return {};
+    }
+    if (targetUpdateChange) {
+        await session.changeElements([targetUpdateChange]);
+    }
+    const edgeId = randomUUID().replace(/-/g, '');
+    const edgeElement = buildEdgeElement({
+        id: edgeId,
+        edge: {
+            ...edge,
+            fromHandle,
+            toHandle,
+        },
+        sourceId,
+        targetId,
+    });
+    await session.addElements([edgeElement]);
+    existingEdgeKeys.add(edgeKey);
+    return { createdEdgeId: edgeId };
+}
+async function tryCreateImplicitInputSourceEdge(sourceId, targetId, session, existingEdgeKeys) {
+    const sourceElement = session.getElement(sourceId);
+    const targetElement = session.getElement(targetId);
+    if (!sourceElement || !targetElement) {
+        return {};
+    }
+    let fromHandle = normalizeSourceHandle(sourceElement, resolveDefaultSourceHandle(sourceElement));
+    const inputTarget = ensureInputTargetHandle(targetElement, sourceElement, sourceId, fromHandle);
+    fromHandle = normalizeSourceHandle(sourceElement, fromHandle);
+    const edgeKey = buildEdgeKey(sourceId, targetId, fromHandle, inputTarget.handle);
+    if (existingEdgeKeys.has(edgeKey)) {
+        return {};
+    }
+    await session.changeElements([inputTarget.change]);
+    const edgeId = randomUUID().replace(/-/g, '');
+    const edgeElement = buildEdgeElement({
+        id: edgeId,
+        edge: {
+            from: sourceId,
+            to: targetId,
+            fromHandle,
+            toHandle: inputTarget.handle,
+        },
+        sourceId,
+        targetId,
+    });
+    await session.addElements([edgeElement]);
+    existingEdgeKeys.add(edgeKey);
+    return { createdEdgeId: edgeId };
+}
+function ensureSelectorTargetHandle(targetElement, sourceElement, sourceId, fromHandle) {
+    const targetData = asRecord(targetElement.data);
+    const currentMedias = asRecord(targetData.medias);
+    const existingHandle = findExistingSelectorHandle(currentMedias, sourceId, fromHandle);
+    if (existingHandle) {
+        return {
+            handle: existingHandle,
+            change: {
+                id: targetElement.id,
+                data: {
+                    medias: currentMedias,
+                    selectedId: typeof targetData.selectedId === 'string' && targetData.selectedId.length > 0
+                        ? targetData.selectedId
+                        : existingHandle,
+                },
+            },
+        };
+    }
+    const handle = randomUUID().replace(/-/g, '');
+    const sourceMedia = resolveSourceMedia(sourceElement, fromHandle);
+    const mediaType = sourceMedia?.type === 'video' ? 'video' : 'image';
+    currentMedias[handle] = {
+        id: handle,
+        name: sourceMedia?.name || mediaType,
+        type: mediaType,
+        url: sourceMedia?.url || '',
+        width: sourceMedia?.width || 1024,
+        height: sourceMedia?.height || 1024,
+        source: sourceId,
+    };
+    return {
+        handle,
+        change: {
+            id: targetElement.id,
+            data: {
+                medias: currentMedias,
+                selectedId: typeof targetData.selectedId === 'string' && targetData.selectedId.length > 0
+                    ? targetData.selectedId
+                    : handle,
+            },
+        },
+    };
+}
+function ensureInputTargetHandle(targetElement, sourceElement, sourceId, fromHandle) {
+    const targetData = asRecord(targetElement.data);
+    if (sourceElement.type === CANVAS_NODE_TYPES.REFINE) {
+        const currentAddons = asRecord(targetData.addons);
+        const existingAddonHandle = findExistingAddonHandle(currentAddons, sourceId, fromHandle);
+        if (existingAddonHandle) {
+            currentAddons[existingAddonHandle] = {
+                ...asRecord(currentAddons[existingAddonHandle]),
+                prompt: resolveSourcePrompt(sourceElement, fromHandle),
+            };
+            return {
+                handle: existingAddonHandle,
+                change: {
+                    id: targetElement.id,
+                    data: {
+                        addons: currentAddons,
+                    },
+                },
+            };
+        }
+        const handle = randomUUID().replace(/-/g, '');
+        currentAddons[handle] = {
+            id: handle,
+            index: Object.keys(currentAddons).length + 1,
+            prompt: resolveSourcePrompt(sourceElement, fromHandle),
+            source: sourceId,
+        };
+        return {
+            handle,
+            change: {
+                id: targetElement.id,
+                data: {
+                    addons: currentAddons,
+                },
+            },
+        };
+    }
+    const sourceMedia = resolveSourceMedia(sourceElement, fromHandle);
+    const mediaType = sourceMedia?.type === 'video' ? 'video' : 'image';
+    const currentMedias = asRecord(targetData.medias);
+    const existingMediaHandle = findExistingInputMediaHandle(currentMedias, sourceId, fromHandle);
+    if (existingMediaHandle) {
+        currentMedias[existingMediaHandle] = {
+            ...asRecord(currentMedias[existingMediaHandle]),
+            name: sourceMedia?.name || mediaType,
+            type: sourceMedia?.type || mediaType,
+            url: sourceMedia?.url || '',
+            width: sourceMedia?.width || 1024,
+            height: sourceMedia?.height || 1024,
+            source: sourceId,
+            sourceHandle: fromHandle || existingMediaHandle,
+        };
+        return {
+            handle: existingMediaHandle,
+            change: {
+                id: targetElement.id,
+                data: {
+                    medias: currentMedias,
+                },
+            },
+        };
+    }
+    const handle = randomUUID().replace(/-/g, '');
+    currentMedias[handle] = {
+        id: handle,
+        name: sourceMedia?.name || mediaType,
+        type: sourceMedia?.type || mediaType,
+        url: sourceMedia?.url || '',
+        width: sourceMedia?.width || 1024,
+        height: sourceMedia?.height || 1024,
+        source: sourceId,
+        sourceHandle: fromHandle || handle,
+    };
+    return {
+        handle,
+        change: {
+            id: targetElement.id,
+            data: {
+                medias: currentMedias,
+            },
+        },
+    };
+}
+function resolveSourcePrompt(sourceElement, fromHandle) {
+    const sourceData = asRecord(sourceElement.data);
+    if (sourceElement.type === CANVAS_NODE_TYPES.REFINE) {
+        const outputs = asRecord(sourceData.multi_outputs);
+        const output = fromHandle ? asRecord(outputs[fromHandle]) : asRecord(outputs[Object.keys(outputs)[0]]);
+        if (typeof output.prompt === 'string') {
+            return output.prompt;
+        }
+        if (typeof sourceData.output_text === 'string') {
+            return sourceData.output_text;
+        }
+    }
+    if (typeof sourceData.prompt === 'string') {
+        return sourceData.prompt;
+    }
+    return '';
+}
+function resolveSourceMedia(sourceElement, fromHandle) {
+    const sourceData = asRecord(sourceElement.data);
+    const mediasValue = sourceData.medias;
+    if (Array.isArray(mediasValue)) {
+        if (fromHandle) {
+            const matched = mediasValue.find((media) => asRecord(media).id === fromHandle);
+            if (matched) {
+                return asRecord(matched);
+            }
+        }
+        return mediasValue.length > 0 ? asRecord(mediasValue[0]) : null;
+    }
+    const medias = asRecord(mediasValue);
+    if (fromHandle && isRecord(medias[fromHandle])) {
+        return asRecord(medias[fromHandle]);
+    }
+    if (typeof sourceData.selectedId === 'string' && isRecord(medias[sourceData.selectedId])) {
+        return asRecord(medias[sourceData.selectedId]);
+    }
+    const keys = Object.keys(medias);
+    if (keys.length > 0 && isRecord(medias[keys[0]])) {
+        return asRecord(medias[keys[0]]);
+    }
+    if (typeof sourceData.url === 'string' && sourceData.url.length > 0) {
+        return {
+            id: fromHandle || randomUUID().replace(/-/g, ''),
+            url: sourceData.url,
+            type: sourceElement.type === CANVAS_NODE_TYPES.VIDEO ? 'video' : 'image',
+        };
+    }
+    return null;
+}
+function asRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function buildExistingNodeRefMap(elements, planId) {
+    const map = new Map();
+    for (const element of elements) {
+        const data = asRecord(element.data);
+        const ref = typeof data.plan_ref === 'string' ? data.plan_ref : undefined;
+        if (!ref)
+            continue;
+        // When planId is provided, only match nodes from the same plan.
+        // This prevents cross-plan ref collisions (e.g. both plans using N1, N2...).
+        if (planId && typeof data.plan_id === 'string' && data.plan_id !== planId) {
+            continue;
+        }
+        map.set(ref, element.id);
+    }
+    return map;
+}
+function buildExistingEdgeKeySet(elements) {
+    const set = new Set();
+    for (const element of elements) {
+        const edge = element;
+        if (element.type !== CANVAS_NODE_TYPES.EDGE || !edge.source || !edge.target) {
+            continue;
+        }
+        set.add(buildEdgeKey(edge.source, edge.target, edge.sourceHandle, edge.targetHandle));
+    }
+    return set;
+}
+function buildEdgeKey(sourceId, targetId, fromHandle, toHandle) {
+    return [sourceId, targetId, fromHandle || '', toHandle || ''].join('::');
+}
+function findExistingBatchInputId(elements, sourceId, outputIndex) {
+    for (const element of elements) {
+        if (element.type !== CANVAS_NODE_TYPES.INPUT) {
+            continue;
+        }
+        const data = asRecord(element.data);
+        const addons = asRecord(data.addons);
+        const addon = Object.values(addons).map(asRecord)[0];
+        if (!addon) {
+            continue;
+        }
+        if (String(addon.index ?? '') !== String(Number(outputIndex) + 1)) {
+            continue;
+        }
+        const hasSourceEdge = elements.some((candidate) => {
+            const edge = candidate;
+            return (candidate.type === CANVAS_NODE_TYPES.EDGE &&
+                edge.source === sourceId &&
+                edge.target === element.id);
+        });
+        if (hasSourceEdge) {
+            return element.id;
+        }
+    }
+    return undefined;
+}
+function findExistingBatchProcessIds(elements, inputId) {
+    return elements
+        .filter((element) => {
+        const edge = element;
+        return (element.type === CANVAS_NODE_TYPES.EDGE &&
+            edge.source === inputId &&
+            typeof edge.target === 'string');
+    })
+        .map((edge) => edge.target)
+        .filter((targetId) => {
+        const target = elements.find((element) => element.id === targetId);
+        return Boolean(target &&
+            (target.type === CANVAS_NODE_TYPES.PROCESS ||
+                target.type === CANVAS_NODE_TYPES.REFINE ||
+                target.type === CANVAS_NODE_TYPES.CROP));
+    });
+}
+function getExpectedProcessOutputCount(processElement) {
+    if (!processElement) {
+        return 1;
+    }
+    const processData = asRecord(processElement.data);
+    if (Array.isArray(processData.medias) && processData.medias.length > 0) {
+        return processData.medias.length;
+    }
+    const medias = asRecord(processData.medias);
+    if (Object.keys(medias).length > 0) {
+        return Object.keys(medias).length;
+    }
+    if (typeof processData.count === 'number' && processData.count > 1) {
+        return processData.count;
+    }
+    return 1;
+}
+function sanitizeRefFragment(value) {
+    return value.replace(/[^a-zA-Z0-9_-]+/g, '_').slice(0, 40) || 'model';
+}
+function findExistingSelectorHandle(medias, sourceId, fromHandle) {
+    return Object.entries(medias).find(([, media]) => {
+        const record = asRecord(media);
+        return (record.source === sourceId &&
+            (!fromHandle || record.sourceHandle === fromHandle));
+    })?.[0];
+}
+function findExistingAddonHandle(addons, sourceId, fromHandle) {
+    return Object.entries(addons).find(([, addon]) => {
+        const record = asRecord(addon);
+        return (record.source === sourceId &&
+            (!fromHandle || record.sourceHandle === fromHandle || record.id === fromHandle));
+    })?.[0];
+}
+function findExistingInputMediaHandle(medias, sourceId, fromHandle) {
+    return Object.entries(medias).find(([, media]) => {
+        const record = asRecord(media);
+        return (record.source === sourceId &&
+            (!fromHandle || record.sourceHandle === fromHandle));
+    })?.[0];
+}