windmill-components 1.642.0 → 1.655.0

package/package/components/graph/graphBuilder.svelte.d.ts

@@ -8,11 +8,11 @@ export type InsertKind = 'script' | 'forloop' | 'whileloop' | 'branchone' | 'bra
 export type InlineScript = {
     language: RawScript['language'];
     kind: Script['kind'];
-    subkind: 'pgsql' | 'flow';
+    subkind: 'pgsql' | 'flow' | 'claudesandbox';
     summary?: string;
     instructions?: string;
 };
-export type onSelectedIteration = (detail: {
+export type OnSelectedIteration = (detail: {
     id: string;
     index: number;
     manuallySet: true;
@@ -52,7 +52,10 @@ export type GraphEventHandlers = {
     move: (detail: {
         id: string;
     }) => void;
-    selectedIteration: onSelectedIteration;
+    duplicate: (detail: {
+        id: string;
+    }) => void;
+    selectedIteration: OnSelectedIteration;
     changeId: (newId: string) => void;
     simplifyFlow: (b: boolean) => void;
     expandSubflow: (id: string, path: string) => void;
@@ -76,9 +79,7 @@ export declare function buildPrefix(prefix: string | undefined, id: string): str
 export type NodeLayout = {
     id: string;
     parentIds?: string[];
-    data: {
-        offset?: number;
-    };
+    data: {};
     selectable?: boolean;
 } & FlowNode;
 export type FlowNode = InputN | ModuleN | BranchAllStartN | BranchAllEndN | ForLoopEndN | ForLoopStartN | ResultN | WhileLoopStartN | WhileLoopEndN | BranchOneStartN | BranchOneEndN | SubflowBoundN | NoBranchN | TriggerN | AssetN | AssetsOverflowedN | AiToolN | NewAiToolN;
@@ -88,7 +89,6 @@ export type InputN = {
         eventHandlers: GraphEventHandlers;
         hasPreprocessor: boolean;
         insertable: boolean;
-        moving: string | undefined;
         disableAi: boolean;
         cache: boolean;
         earlyStop: boolean;
@@ -106,12 +106,10 @@ export type InputN = {
 export type ModuleN = {
     type: 'module';
     data: {
-        offset: number;
         module: FlowModule;
         id: string;
         parentIds: string[];
         eventHandlers: GraphEventHandlers;
-        moving: string | undefined;
         flowModuleState: GraphModuleState | undefined;
         testModuleState: ModuleTestState | undefined;
         insertable: boolean;
@@ -125,7 +123,6 @@ export type ModuleN = {
 export type BranchAllStartN = {
     type: 'branchAllStart';
     data: {
-        offset: number;
         label: string;
         id: string;
         branchIndex: number;
@@ -138,7 +135,6 @@ export type BranchAllStartN = {
 export type BranchAllEndN = {
     type: 'branchAllEnd';
     data: {
-        offset: number;
         id: string;
         eventHandlers: GraphEventHandlers;
         flowModuleState: GraphModuleState | undefined;
@@ -147,7 +143,6 @@ export type BranchAllEndN = {
 export type ForLoopEndN = {
     type: 'forLoopEnd';
     data: {
-        offset: number;
         id: string;
         eventHandlers: GraphEventHandlers;
         simplifiedTriggerView: boolean;
@@ -157,7 +152,6 @@ export type ForLoopEndN = {
 export type ForLoopStartN = {
     type: 'forLoopStart';
     data: {
-        offset: number;
         id: string;
         eventHandlers: GraphEventHandlers;
         flowModuleState: GraphModuleState | undefined;
@@ -180,20 +174,16 @@ export type ResultN = {
 export type WhileLoopStartN = {
     type: 'whileLoopStart';
     data: {
-        offset: number;
         eventHandlers: GraphEventHandlers;
     };
 };
 export type WhileLoopEndN = {
     type: 'whileLoopEnd';
-    data: {
-        offset: number;
-    };
+    data: {};
 };
 export type BranchOneStartN = {
     type: 'branchOneStart';
     data: {
-        offset: number;
         id: string;
         eventHandlers: GraphEventHandlers;
         flowModuleState: GraphModuleState | undefined;
@@ -208,7 +198,6 @@ export type BranchOneStartN = {
 export type BranchOneEndN = {
     type: 'branchOneEnd';
     data: {
-        offset: number;
         id: string;
         eventHandlers: GraphEventHandlers;
         flowModuleState: GraphModuleState | undefined;
@@ -217,7 +206,6 @@ export type BranchOneEndN = {
 export type SubflowBoundN = {
     type: 'subflowBound';
     data: {
-        offset: number;
         id: string;
         eventHandlers: GraphEventHandlers;
         label: string;
@@ -229,7 +217,6 @@ export type SubflowBoundN = {
 export type NoBranchN = {
     type: 'noBranch';
     data: {
-        offset: number;
         id: string;
         eventHandlers: GraphEventHandlers;
         flowModuleState: GraphModuleState | undefined;
@@ -312,7 +299,7 @@ export declare function graphBuilder(modules: FlowModule[] | undefined, extra: {
     flowHasChanged: boolean;
     chatInputEnabled: boolean;
     additionalAssetsMap?: Record<string, AssetWithAltAccessType[]>;
-}, failureModule: FlowModule | undefined, preprocessorModule: FlowModule | undefined, eventHandlers: GraphEventHandlers, success: boolean | undefined, useDataflow: boolean | undefined, selectedId: string | undefined, moving: string | undefined, simplifiableFlow: SimplifiableFlow | undefined, flowPathForTriggerNode: string | undefined, expandedSubflows: Record<string, FlowModule[]>): {
+}, failureModule: FlowModule | undefined, preprocessorModule: FlowModule | undefined, eventHandlers: GraphEventHandlers, success: boolean | undefined, useDataflow: boolean | undefined, selectedId: string | undefined, simplifiableFlow: SimplifiableFlow | undefined, flowPathForTriggerNode: string | undefined, expandedSubflows: Record<string, FlowModule[]>): {
     nodes: {
         [key: string]: NodeLayout;
     };

package/package/components/graph/graphBuilder.svelte.js

@@ -41,7 +41,7 @@ export function topologicalSort(nodes) {
 // subflowBound: SubflowBound,
 // noBranch: NoBranchNode,
 // trigger: TriggersNode
-export function graphBuilder(modules, extra, failureModule, preprocessorModule, eventHandlers, success, useDataflow, selectedId, moving, simplifiableFlow, flowPathForTriggerNode, expandedSubflows
+export function graphBuilder(modules, extra, failureModule, preprocessorModule, eventHandlers, success, useDataflow, selectedId, simplifiableFlow, flowPathForTriggerNode, expandedSubflows
 // triggerProps?: {
 // 	path?: string
 // 	flowIsSimplifiable?: boolean
@@ -54,27 +54,22 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
         }
         const nodes = [];
         const edges = [];
-        function addNode(module, offset) {
+        function addNode(module) {
             const duplicated = nodes.find((n) => n.id === module.id);
             if (duplicated) {
                 console.log('Duplicated node detected: ', module, duplicated);
                 throw new Error(`Duplicated node detected: ${module.id}`);
             }
-            if (module.id.startsWith('subflow:')) {
-                extra.insertable = false;
-            }
             nodes.push({
                 id: module.id,
                 data: {
-                    offset: offset,
                     module: module,
                     id: module.id,
                     parentIds: [],
                     eventHandlers: eventHandlers,
-                    moving: moving,
                     flowModuleState: extra.flowModuleStates?.[module.id],
                     testModuleState: extra.testModuleStates?.states?.[module.id],
-                    insertable: extra.insertable,
+                    insertable: extra.insertable && !module.id.startsWith('subflow:'),
                     editMode: extra.editMode,
                     isOwner: extra.isOwner,
                     flowJob: extra.flowJob,
@@ -136,7 +131,6 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                     sourceId,
                     targetId,
                     branch,
-                    moving,
                     eventHandlers,
                     simplifiedTriggerView: simplifiableFlow?.simplifiedFlow,
                     disableMoveIds: options?.disableMoveIds,
@@ -158,7 +152,6 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                 eventHandlers: eventHandlers,
                 hasPreprocessor: !!preprocessorModule || flowPathForTriggerNode == undefined,
                 insertable: extra.insertable,
-                moving: moving,
                 disableAi: extra.disableAi,
                 cache: extra.cache,
                 earlyStop: extra.earlyStop,
@@ -214,7 +207,7 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
             nodes.push(inputNode);
             nodes.push(resultNode);
         }
-        function processModules(modules, branch, beforeNode, nextNode, simplifiedTriggerView, prefix, currentOffset = 0, disableMoveIds = [], parentIndex) {
+        function processModules(modules, branch, beforeNode, nextNode, simplifiedTriggerView, prefix, disableMoveIds = [], parentIndex) {
             if (prefix != undefined) {
                 modules.forEach((m) => {
                     if (!m['oid']) {
@@ -244,12 +237,11 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                     }
                     if (module.value.type === 'branchall') {
                         // Start
-                        addNode(module, currentOffset);
+                        addNode(module);
                         // "Collect result of each branch" node
                         const endNode = {
                             id: `${module.id}-end`,
                             data: {
-                                offset: currentOffset,
                                 id: module.id,
                                 eventHandlers: eventHandlers,
                                 flowModuleState: extra.flowModuleStates?.[module.id]
@@ -262,7 +254,6 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                             const startNode = {
                                 id: `${module.id}-branch-0`,
                                 data: {
-                                    offset: currentOffset,
                                     id: module.id,
                                     branchIndex: -1,
                                     eventHandlers: eventHandlers,
@@ -286,7 +277,6 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                                 const startNode = {
                                     id: `${module.id}-branch-${branchIndex}`,
                                     data: {
-                                        offset: currentOffset,
                                         label: defaultIfEmptyString(branch.summary, `Branch ${branchIndex + 1}`),
                                         id: module.id,
                                         branchIndex: branchIndex,
@@ -301,19 +291,18 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                                 addEdge(module.id, startNode.id, { rootId: module.id, branch: branchIndex }, prefix, {
                                     type: 'empty'
                                 });
-                                processModules(branch.modules, { rootId: module.id, branch: branchIndex }, startNode, endNode, false, prefix, currentOffset, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}-${branchIndex}` : `${index}-${branchIndex}`);
+                                processModules(branch.modules, { rootId: module.id, branch: branchIndex }, startNode, endNode, false, prefix, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}-${branchIndex}` : `${index}-${branchIndex}`);
                             });
                         }
                         previousId = endNode.id;
                     }
                     else if (module.value.type === 'forloopflow') {
                         if (!simplifiedTriggerView) {
-                            addNode(module, currentOffset);
+                            addNode(module);
                         }
                         const startNode = {
                             id: `${module.id}-start`,
                             data: {
-                                offset: currentOffset + 25,
                                 id: module.id,
                                 module: module,
                                 simplifiedTriggerView,
@@ -337,7 +326,6 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                         const endNode = {
                             id: `${module.id}-end`,
                             data: {
-                                offset: currentOffset,
                                 id: module.id,
                                 eventHandlers: eventHandlers,
                                 simplifiedTriggerView,
@@ -348,17 +336,16 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                         nodes.push(startNode);
                         nodes.push(endNode);
                         const selectedIterIndex = extra.flowModuleStates?.[module.id]?.selectedForloopIndex;
-                        processModules(module.value.modules, { rootId: module.id, branch: 0 }, startNode, endNode, false, prefix, currentOffset + 25, localDisableMoveIds, parentIndex
+                        processModules(module.value.modules, { rootId: module.id, branch: 0 }, startNode, endNode, false, prefix, localDisableMoveIds, parentIndex
                             ? `${parentIndex}-${index}-${selectedIterIndex ?? '?'}`
                             : `${index}-${selectedIterIndex ?? '?'}`);
                         previousId = endNode.id;
                     }
                     else if (module.value.type === 'whileloopflow') {
-                        addNode(module, currentOffset);
+                        addNode(module);
                         const startNode = {
                             id: `${module.id}-start`,
                             data: {
-                                offset: currentOffset + 25,
                                 eventHandlers: eventHandlers
                             },
                             type: 'whileLoopStart'
@@ -368,23 +355,22 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                         });
                         const endNode = {
                             id: `${module.id}-end`,
-                            data: { offset: currentOffset, ...extra },
+                            data: { ...extra },
                             type: 'whileLoopEnd'
                         };
                         nodes.push(startNode);
                         nodes.push(endNode);
                         const selectedIterIndex = extra.flowModuleStates?.[module.id]?.selectedForloopIndex;
-                        processModules(module.value.modules, { rootId: module.id, branch: 0 }, startNode, endNode, false, prefix, currentOffset + 25, localDisableMoveIds, parentIndex
+                        processModules(module.value.modules, { rootId: module.id, branch: 0 }, startNode, endNode, false, prefix, localDisableMoveIds, parentIndex
                             ? `${parentIndex}-${index}-${selectedIterIndex ?? '?'}`
                             : `${index}-${selectedIterIndex ?? '?'}`);
                         previousId = endNode.id;
                     }
                     else if (module.value.type === 'branchone') {
-                        addNode(module, currentOffset);
+                        addNode(module);
                         const endNode = {
                             id: `${module.id}-end`,
                             data: {
-                                offset: currentOffset,
                                 eventHandlers: eventHandlers,
                                 flowModuleState: extra.flowModuleStates?.[module.id],
                                 id: module.id
@@ -396,7 +382,7 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                         // const defaultBranch: NodeLayout = {
                         // 	id: `${module.id}-default`,
                         // 	data: {
-                        // 		offset: currentOffset,
+                        // 		offset: 0,
                         // 		label: 'Default',
                         // 		id: module.id,
                         // 		branchIndex: -1,
@@ -409,7 +395,6 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                         const defaultBranch = {
                             id: `${module.id}-branch-default`,
                             data: {
-                                offset: currentOffset,
                                 label: 'Default',
                                 id: module.id,
                                 branchIndex: -1,
@@ -426,13 +411,12 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                         addEdge(module.id, defaultBranch.id, { rootId: module.id, branch: 0 }, prefix, {
                             type: 'empty'
                         });
-                        processModules(module.value.default, { rootId: module.id, branch: 0 }, defaultBranch, endNode, false, prefix, currentOffset, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}` : index.toString());
+                        processModules(module.value.default, { rootId: module.id, branch: 0 }, defaultBranch, endNode, false, prefix, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}` : index.toString());
                         module.value.branches.forEach((branch, branchIndex) => {
                             // Start node by branch
                             const startNode = {
                                 id: `${module.id}-branch-${branchIndex}`,
                                 data: {
-                                    offset: currentOffset,
                                     label: defaultIfEmptyString(branch.summary, 'Branch ' + (branchIndex + 1)),
                                     preLabel: branch.summary ? '' : branch.expr,
                                     id: module.id,
@@ -449,7 +433,7 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                             addEdge(module.id, startNode.id, { rootId: module.id, branch: branchIndex }, prefix, {
                                 type: 'empty'
                             });
-                            processModules(branch.modules, { rootId: module.id, branch: branchIndex + 1 }, startNode, endNode, false, prefix, currentOffset, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}` : index.toString());
+                            processModules(branch.modules, { rootId: module.id, branch: branchIndex + 1 }, startNode, endNode, false, prefix, localDisableMoveIds, parentIndex ? `${parentIndex}-${index}` : index.toString());
                         });
                         previousId = endNode.id;
                     }
@@ -464,7 +448,6 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                             const startNode = {
                                 id: startId,
                                 data: {
-                                    offset: currentOffset,
                                     label: `Start of subflow ${idWithoutPrefix}`,
                                     id: startId,
                                     subflowId: module.id,
@@ -476,18 +459,21 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                             };
                             nodes.push(startNode);
                             if (previousId) {
-                                addEdge(previousId, startNode.id, undefined, prefix, {
-                                    type: 'empty'
+                                addEdge(previousId, startNode.id, branch, prefix, {
+                                    subModules: modules,
+                                    disableMoveIds
                                 });
                             }
                             else {
-                                addEdge(beforeNode.id, startNode.id, undefined, prefix, { type: 'empty' });
+                                addEdge(beforeNode.id, startNode.id, undefined, prefix, {
+                                    subModules: modules,
+                                    disableMoveIds
+                                });
                             }
                             const endId = `${module.id}-subflow-end`;
                             const endNode = {
                                 id: endId,
                                 data: {
-                                    offset: currentOffset,
                                     label: `End of subflow ${idWithoutPrefix}`,
                                     id: endId,
                                     subflowId: module.id,
@@ -498,11 +484,11 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                                 type: 'subflowBound'
                             };
                             nodes.push(endNode);
-                            processModules(expanded, undefined, startNode, endNode, false, buildPrefix(prefix, module['oid'] ?? module.id), currentOffset, localDisableMoveIds);
+                            processModules(expanded, undefined, startNode, endNode, false, buildPrefix(prefix, module['oid'] ?? module.id), localDisableMoveIds);
                             previousId = endNode.id;
                         }
                         else {
-                            addNode(module, currentOffset);
+                            addNode(module);
                             previousId = module.id;
                         }
                     }
@@ -539,17 +525,17 @@ export function graphBuilder(modules, extra, failureModule, preprocessorModule,
                 }
             });
             Object.entries(toAdd).forEach((x) => {
-                addNode({ ...failureModule, id: x[1] }, 0);
+                addNode({ ...failureModule, id: x[1] });
                 addEdge(x[0], x[1], undefined, undefined, { type: 'empty' });
             });
         }
         if (preprocessorModule) {
-            addNode(preprocessorModule, 0);
+            addNode(preprocessorModule);
             const id = JSON.parse(JSON.stringify(preprocessorModule.id));
             addEdge(id, 'Input', undefined, undefined, { type: 'empty' });
         }
         if (failureModule && !extra.flowModuleStates) {
-            addNode(failureModule, 0);
+            addNode(failureModule);
         }
         Object.keys(parents).forEach((key) => {
             const node = nodes.find((n) => n.id === key);

package/package/components/graph/graphContext.d.ts

@@ -1,5 +1,6 @@
 import type { SelectionManager } from './selectionUtils.svelte';
 import type { NoteManager } from './noteManager.svelte';
+import type { MoveManager } from './moveManager.svelte';
 import type { Writable } from 'svelte/store';
 import type { FlowDiffManager } from '../flows/flowDiffManager.svelte';
 export type GraphContext = {
@@ -7,6 +8,7 @@ export type GraphContext = {
     useDataflow: Writable<boolean | undefined>;
     showAssets: Writable<boolean | undefined>;
     noteManager?: NoteManager;
+    moveManager?: MoveManager;
     clearFlowSelection?: () => void;
     yOffset?: number;
     diffManager: FlowDiffManager;

package/package/components/graph/moveManager.svelte.d.ts

@@ -0,0 +1,74 @@
+export type DropZone = {
+    edgeId: string;
+    sourceId: string;
+    targetId: string;
+    branch: {
+        rootId: string;
+        branch: number;
+    } | undefined;
+    index: number;
+    flowPosition: {
+        x: number;
+        y: number;
+    };
+    disableMoveIds: string[];
+};
+export type DropZoneRegistration = {
+    sourceId: string;
+    targetId: string;
+    branch: {
+        rootId: string;
+        branch: number;
+    } | undefined;
+    index: number;
+    disableMoveIds: string[];
+    centerX: number;
+    centerY: number;
+};
+type DragInfo = {
+    moduleId: string;
+    selectedIds?: string[];
+};
+/**
+ * Compute the set of node IDs belonging to a subflow (or a single step).
+ * Includes the module itself, all nested children (id starts with `moduleId-`),
+ * and structural edge endpoints whose `disableMoveIds` reference this module.
+ */
+export declare function getSubflowNodeIds(moduleId: string, allNodes: {
+    id: string;
+}[], allEdges: {
+    source: string;
+    target: string;
+    data?: any;
+}[]): Set<string>;
+export declare class MoveManager {
+    #private;
+    dragging: DragInfo | undefined;
+    ghostScreenX: number;
+    ghostScreenY: number;
+    nearestDropZone: DropZone | undefined;
+    draggedNodeIds: Set<string>;
+    /** The module ID currently being moved via legacy click-to-move */
+    movingModuleId: string | undefined;
+    /** Multiple module IDs being moved together (multi-select move) */
+    movingIds: string[] | undefined;
+    toggleMoving(id: string): void;
+    toggleMovingMultiple(ids: string[]): void;
+    setMoving(id: string): void;
+    clearMoving(): void;
+    setComputeDraggedNodeIds(fn: (moduleIds: string[]) => Set<string>): void;
+    setScreenToFlowPosition(fn: (pos: {
+        x: number;
+        y: number;
+    }) => {
+        x: number;
+        y: number;
+    }): void;
+    registerDropZone(edgeId: string, zone: DropZoneRegistration): void;
+    unregisterDropZone(edgeId: string): void;
+    startDrag(moduleId: string, screenX: number, screenY: number, selectedIds?: string[]): void;
+    updateDrag(screenX: number, screenY: number): void;
+    endDrag(): DropZone | undefined;
+    cancelDrag(): void;
+}
+export {};

package/package/components/graph/moveManager.svelte.js

@@ -0,0 +1,176 @@
+import { NODE } from './util';
+/**
+ * Compute the set of node IDs belonging to a subflow (or a single step).
+ * Includes the module itself, all nested children (id starts with `moduleId-`),
+ * and structural edge endpoints whose `disableMoveIds` reference this module.
+ */
+export function getSubflowNodeIds(moduleId, allNodes, allEdges) {
+    const nodeIdPrefix = moduleId + '-';
+    const nodeIds = new Set();
+    for (const n of allNodes) {
+        if (n.id === moduleId || n.id.startsWith(nodeIdPrefix)) {
+            nodeIds.add(n.id);
+        }
+    }
+    for (const e of allEdges) {
+        const disableIds = e.data?.disableMoveIds ?? [];
+        if (disableIds.includes(moduleId)) {
+            nodeIds.add(e.source);
+            nodeIds.add(e.target);
+        }
+    }
+    // Include child nodes (e.g. asset/AI tool nodes) of nodes added via edges.
+    // Nodes found through disableMoveIds (like inner module "b") may have children
+    // ("b-asset-in-...") that weren't caught by the initial prefix match on moduleId.
+    const edgeMatchedIds = [...nodeIds];
+    for (const n of allNodes) {
+        if (!nodeIds.has(n.id)) {
+            for (const id of edgeMatchedIds) {
+                if (n.id.startsWith(id + '-')) {
+                    nodeIds.add(n.id);
+                    break;
+                }
+            }
+        }
+    }
+    return nodeIds;
+}
+export class MoveManager {
+    dragging = $state(undefined);
+    ghostScreenX = $state(0);
+    ghostScreenY = $state(0);
+    nearestDropZone = $state(undefined);
+    draggedNodeIds = $state(new Set());
+    /** The module ID currently being moved via legacy click-to-move */
+    movingModuleId = $state(undefined);
+    /** Multiple module IDs being moved together (multi-select move) */
+    movingIds = $state(undefined);
+    toggleMoving(id) {
+        if (this.movingModuleId === id) {
+            this.movingModuleId = undefined;
+            this.#updateDraggedNodeIds(undefined);
+        }
+        else {
+            this.movingModuleId = id;
+            this.#updateDraggedNodeIds([id]);
+        }
+    }
+    toggleMovingMultiple(ids) {
+        if (this.movingIds &&
+            this.movingIds.length === ids.length &&
+            this.movingIds.every((id, i) => id === ids[i])) {
+            this.movingModuleId = undefined;
+            this.movingIds = undefined;
+            this.#updateDraggedNodeIds(undefined);
+        }
+        else {
+            this.movingModuleId = ids[0];
+            this.movingIds = ids;
+            this.#updateDraggedNodeIds(ids);
+        }
+    }
+    setMoving(id) {
+        this.movingModuleId = id;
+        this.#updateDraggedNodeIds([id]);
+    }
+    clearMoving() {
+        this.movingModuleId = undefined;
+        this.movingIds = undefined;
+        this.#updateDraggedNodeIds(undefined);
+    }
+    #computeDraggedNodeIds;
+    setComputeDraggedNodeIds(fn) {
+        this.#computeDraggedNodeIds = fn;
+    }
+    #updateDraggedNodeIds(moduleIds) {
+        this.draggedNodeIds =
+            moduleIds && moduleIds.length > 0 && this.#computeDraggedNodeIds
+                ? this.#computeDraggedNodeIds(moduleIds)
+                : new Set();
+    }
+    #screenToFlowPosition;
+    #registeredDropZones = new Map();
+    setScreenToFlowPosition(fn) {
+        this.#screenToFlowPosition = fn;
+    }
+    registerDropZone(edgeId, zone) {
+        this.#registeredDropZones.set(edgeId, zone);
+    }
+    unregisterDropZone(edgeId) {
+        this.#registeredDropZones.delete(edgeId);
+    }
+    startDrag(moduleId, screenX, screenY, selectedIds) {
+        // Clear any active click-to-move so only drag mode is active
+        this.movingModuleId = undefined;
+        this.dragging = { moduleId, selectedIds };
+        this.ghostScreenX = screenX;
+        this.ghostScreenY = screenY;
+        this.nearestDropZone = undefined;
+        // Compute dragged node IDs for the primary module plus any additional selected modules
+        const allIds = selectedIds && selectedIds.length > 0
+            ? [moduleId, ...selectedIds.filter((id) => id !== moduleId)]
+            : [moduleId];
+        this.#updateDraggedNodeIds(allIds);
+    }
+    updateDrag(screenX, screenY) {
+        if (!this.dragging)
+            return;
+        this.ghostScreenX = screenX;
+        this.ghostScreenY = screenY;
+        if (!this.#screenToFlowPosition)
+            return;
+        const flowPos = this.#screenToFlowPosition({ x: screenX, y: screenY });
+        this.nearestDropZone = this.#findNearestDropZone(flowPos);
+    }
+    endDrag() {
+        if (!this.dragging)
+            return undefined;
+        const zone = this.nearestDropZone;
+        this.dragging = undefined;
+        this.nearestDropZone = undefined;
+        this.#updateDraggedNodeIds(undefined);
+        return zone;
+    }
+    cancelDrag() {
+        this.dragging = undefined;
+        this.nearestDropZone = undefined;
+        this.#updateDraggedNodeIds(undefined);
+    }
+    #findNearestDropZone(flowPos) {
+        if (!this.dragging)
+            return undefined;
+        const draggedId = this.dragging.moduleId;
+        let best = undefined;
+        let bestDist = Infinity;
+        // Box half-dimensions matching the visual drop zone
+        const halfW = NODE.width / 2;
+        const halfH = NODE.gap.vertical / 2;
+        for (const [edgeId, zone] of this.#registeredDropZones) {
+            if (zone.disableMoveIds.includes(draggedId))
+                continue;
+            // Skip edges adjacent to the dragged node (no-op move)
+            if (zone.sourceId === draggedId || zone.targetId === draggedId)
+                continue;
+            const dx = Math.abs(flowPos.x - zone.centerX);
+            const dy = Math.abs(flowPos.y - zone.centerY);
+            // Axis-aligned bounding box test
+            if (dx <= halfW && dy <= halfH) {
+                // Manhattan-like distance for ranking overlapping boxes
+                const dist = dx + dy;
+                if (dist < bestDist) {
+                    bestDist = dist;
+                    best = {
+                        edgeId,
+                        sourceId: zone.sourceId,
+                        targetId: zone.targetId,
+                        branch: zone.branch,
+                        index: zone.index,
+                        flowPosition: { x: zone.centerX, y: zone.centerY },
+                        disableMoveIds: zone.disableMoveIds
+                    };
+                }
+            }
+        }
+        return best;
+    }
+}