@d34dman/flowdrop 0.0.52 → 0.0.54

package/dist/helpers/proximityConnect.d.ts

@@ -5,7 +5,7 @@
  * When a node is dragged near another node, this helper finds the best
  * compatible port pair and creates a preview/permanent edge.
  */
-import type { WorkflowNode as WorkflowNodeType, WorkflowEdge, NodePort } from '../types/index.js';
+import type { WorkflowNode as WorkflowNodeType, WorkflowEdge, NodePort, PortCoordinateMap } from '../types/index.js';
 /** A candidate proximity edge before it is finalized */
 export interface ProximityEdgeCandidate {
     id: string;
@@ -26,7 +26,7 @@ export declare class ProximityConnectHelper {
      */
     static buildHandleId(nodeId: string, direction: 'input' | 'output', portId: string): string;
     /**
-     * Calculate center-to-center Euclidean distance between two nodes.
+     * Calculate center-to-center distance between two nodes.
      */
     static getNodeDistance(nodeA: {
         position: {
@@ -51,7 +51,7 @@ export declare class ProximityConnectHelper {
      * Find the single best compatible edge between a dragged node and nearby nodes.
      *
      * Algorithm:
-     * 1. Find the closest node within minDistance
+     * 1. Find the closest node within minDistance (edge-to-edge)
      * 2. Check both directions (dragged->nearby and nearby->dragged)
      * 3. Return the first exact-type match, or first compatible match
      * 4. Skip pairs where an edge already exists or input handle is already connected
@@ -59,6 +59,22 @@ export declare class ProximityConnectHelper {
      * @returns Array with at most ONE ProximityEdgeCandidate
      */
     static findCompatibleEdges(draggedNode: WorkflowNodeType, allNodes: WorkflowNodeType[], existingEdges: WorkflowEdge[], minDistance: number): ProximityEdgeCandidate[];
+    /**
+     * Find the single best compatible edge using port-to-port distance.
+     *
+     * Unlike findCompatibleEdges() which uses node center distance,
+     * this method compares actual handle positions from the port coordinate store.
+     * This is more accurate for large nodes or nodes with many ports.
+     *
+     * Algorithm:
+     * 1. Partition ports by owner (dragged vs other) and direction (input vs output)
+     * 2. Group other-node ports by dataType for O(1) lookup of compatible groups
+     * 3. For each dragged port, only iterate compatible dataType groups
+     * 4. Return the closest compatible pair (exact type match preferred)
+     *
+     * @returns Array with at most ONE ProximityEdgeCandidate
+     */
+    static findCompatibleEdgesByPortCoordinates(draggedNodeId: string, portCoordinates: PortCoordinateMap, existingEdges: WorkflowEdge[], maxDistance: number): ProximityEdgeCandidate[];
     /**
      * Convert candidates to temporary (preview) WorkflowEdge objects with dashed styling.
      */

package/dist/helpers/proximityConnect.js

@@ -48,20 +48,22 @@ export class ProximityConnectHelper {
         return `${nodeId}-${direction}-${portId}`;
     }
     /**
-     * Calculate center-to-center Euclidean distance between two nodes.
+     * Calculate center-to-center distance between two nodes.
      */
     static getNodeDistance(nodeA, nodeB) {
-        const ax = nodeA.position.x + (nodeA.measured?.width ?? 0) / 2;
-        const ay = nodeA.position.y + (nodeA.measured?.height ?? 0) / 2;
-        const bx = nodeB.position.x + (nodeB.measured?.width ?? 0) / 2;
-        const by = nodeB.position.y + (nodeB.measured?.height ?? 0) / 2;
-        return Math.sqrt((ax - bx) ** 2 + (ay - by) ** 2);
+        const aCenterX = nodeA.position.x + (nodeA.measured?.width ?? 0) / 2;
+        const aCenterY = nodeA.position.y + (nodeA.measured?.height ?? 0) / 2;
+        const bCenterX = nodeB.position.x + (nodeB.measured?.width ?? 0) / 2;
+        const bCenterY = nodeB.position.y + (nodeB.measured?.height ?? 0) / 2;
+        const dx = aCenterX - bCenterX;
+        const dy = aCenterY - bCenterY;
+        return Math.sqrt(dx * dx + dy * dy);
     }
     /**
      * Find the single best compatible edge between a dragged node and nearby nodes.
      *
      * Algorithm:
-     * 1. Find the closest node within minDistance
+     * 1. Find the closest node within minDistance (edge-to-edge)
      * 2. Check both directions (dragged->nearby and nearby->dragged)
      * 3. Return the first exact-type match, or first compatible match
      * 4. Skip pairs where an edge already exists or input handle is already connected
@@ -172,6 +174,106 @@ export class ProximityConnectHelper {
         const best = exactMatch ?? compatibleMatch;
         return best ? [best] : [];
     }
+    /**
+     * Find the single best compatible edge using port-to-port distance.
+     *
+     * Unlike findCompatibleEdges() which uses node center distance,
+     * this method compares actual handle positions from the port coordinate store.
+     * This is more accurate for large nodes or nodes with many ports.
+     *
+     * Algorithm:
+     * 1. Partition ports by owner (dragged vs other) and direction (input vs output)
+     * 2. Group other-node ports by dataType for O(1) lookup of compatible groups
+     * 3. For each dragged port, only iterate compatible dataType groups
+     * 4. Return the closest compatible pair (exact type match preferred)
+     *
+     * @returns Array with at most ONE ProximityEdgeCandidate
+     */
+    static findCompatibleEdgesByPortCoordinates(draggedNodeId, portCoordinates, existingEdges, maxDistance) {
+        const checker = getPortCompatibilityChecker();
+        // Build lookup sets for O(1) duplicate/connected checks
+        const existingEdgeSet = new Set(existingEdges.map((e) => `${e.source}:${e.sourceHandle}->${e.target}:${e.targetHandle}`));
+        const connectedTargetHandles = new Set(existingEdges.map((e) => `${e.target}:${e.targetHandle}`));
+        // Partition ports by owner and direction, group other-node ports by dataType
+        const draggedOutputs = [];
+        const draggedInputs = [];
+        const otherInputsByType = new Map();
+        const otherOutputsByType = new Map();
+        for (const coord of portCoordinates.values()) {
+            if (coord.nodeId === draggedNodeId) {
+                if (coord.direction === 'output')
+                    draggedOutputs.push(coord);
+                else
+                    draggedInputs.push(coord);
+            }
+            else {
+                const groupMap = coord.direction === 'input' ? otherInputsByType : otherOutputsByType;
+                let group = groupMap.get(coord.dataType);
+                if (!group) {
+                    group = [];
+                    groupMap.set(coord.dataType, group);
+                }
+                group.push(coord);
+            }
+        }
+        let bestCandidate = null;
+        let bestDistance = Infinity;
+        let bestIsExact = false;
+        const evaluatePair = (sourceCoord, targetCoord) => {
+            // Check for existing edge
+            const edgeKey = `${sourceCoord.nodeId}:${sourceCoord.handleId}->${targetCoord.nodeId}:${targetCoord.handleId}`;
+            if (existingEdgeSet.has(edgeKey))
+                return;
+            // Check target handle not already connected (single-input rule)
+            const targetHandleKey = `${targetCoord.nodeId}:${targetCoord.handleId}`;
+            if (connectedTargetHandles.has(targetHandleKey))
+                return;
+            // Calculate port-to-port distance
+            const dx = sourceCoord.x - targetCoord.x;
+            const dy = sourceCoord.y - targetCoord.y;
+            const dist = Math.sqrt(dx * dx + dy * dy);
+            if (dist > maxDistance)
+                return;
+            const isExact = sourceCoord.dataType === targetCoord.dataType;
+            // Prefer exact match, then closest distance
+            if ((isExact && !bestIsExact) || (isExact === bestIsExact && dist < bestDistance)) {
+                bestCandidate = {
+                    id: `proximity-${uuidv4()}`,
+                    source: sourceCoord.nodeId,
+                    target: targetCoord.nodeId,
+                    sourceHandle: sourceCoord.handleId,
+                    targetHandle: targetCoord.handleId,
+                    sourcePortDataType: sourceCoord.dataType,
+                    targetPortDataType: targetCoord.dataType
+                };
+                bestDistance = dist;
+                bestIsExact = isExact;
+            }
+        };
+        // Direction A: dragged outputs → other inputs (only compatible types)
+        for (const srcPort of draggedOutputs) {
+            const compatibleTypes = checker.getCompatibleTypes(srcPort.dataType);
+            for (const targetType of compatibleTypes) {
+                const targets = otherInputsByType.get(targetType);
+                if (!targets)
+                    continue;
+                for (const tgtPort of targets) {
+                    evaluatePair(srcPort, tgtPort);
+                }
+            }
+        }
+        // Direction B: other outputs → dragged inputs (only compatible types)
+        for (const tgtPort of draggedInputs) {
+            for (const [srcType, sources] of otherOutputsByType) {
+                if (!checker.areDataTypesCompatible(srcType, tgtPort.dataType))
+                    continue;
+                for (const srcPort of sources) {
+                    evaluatePair(srcPort, tgtPort);
+                }
+            }
+        }
+        return bestCandidate ? [bestCandidate] : [];
+    }
     /**
      * Convert candidates to temporary (preview) WorkflowEdge objects with dashed styling.
      */

package/dist/playground/index.d.ts

@@ -125,6 +125,6 @@ export type { PlaygroundSession, PlaygroundMessage, PlaygroundInputField, Playgr
 export { isChatInputNode, CHAT_INPUT_PATTERNS } from '../types/playground.js';
 export type { InterruptType, InterruptStatus, Interrupt, InterruptChoice, InterruptConfig, ConfirmationConfig, ChoiceConfig, TextConfig, FormConfig, InterruptResolution, InterruptApiResponse, InterruptListResponse, InterruptResponse, InterruptMessageMetadata, InterruptPollingConfig } from '../types/interrupt.js';
 export { isInterruptMetadata, extractInterruptMetadata, metadataToInterrupt, defaultInterruptPollingConfig } from '../types/interrupt.js';
-export { interrupts, submittingInterrupts, interruptErrors, pendingInterruptIds, pendingInterrupts, pendingInterruptCount, resolvedInterrupts, isAnySubmitting, interruptActions, getInterrupt, isInterruptPending, isInterruptSubmitting, getInterruptError, getInterruptByMessageId } from '../stores/interruptStore.js';
+export { interrupts, pendingInterruptIds, pendingInterrupts, pendingInterruptCount, resolvedInterrupts, isAnySubmitting, interruptActions, getInterrupt, isInterruptPending, isInterruptSubmitting, getInterruptError, getInterruptByMessageId } from '../stores/interruptStore.js';
 export { mountPlayground, unmountPlayground, type PlaygroundMountOptions, type MountedPlayground } from './mount.js';
 export { createEndpointConfig, defaultEndpointConfig, buildEndpointUrl, type EndpointConfig } from '../config/endpoints.js';

package/dist/playground/index.js

@@ -151,7 +151,7 @@ export { isInterruptMetadata, extractInterruptMetadata, metadataToInterrupt, def
 // ============================================================================
 export { 
 // Core stores
-interrupts, submittingInterrupts, interruptErrors, 
+interrupts, 
 // Derived stores
 pendingInterruptIds, pendingInterrupts, pendingInterruptCount, resolvedInterrupts, isAnySubmitting, 
 // Actions

package/dist/services/portConfigApi.js

@@ -46,16 +46,5 @@ export function validatePortConfig(config) {
             return false;
         }
     }
-    // Check that compatibility rules reference valid data types
-    if (config.compatibilityRules) {
-        // TODO: Fix type definition for PortCompatibilityRule - sourceType and targetType properties missing
-        // const dataTypeIds = new Set(config.dataTypes.map((dt) => dt.id));
-        // for (const rule of config.compatibilityRules) {
-        //   if (!dataTypeIds.has(rule.sourceType) || !dataTypeIds.has(rule.targetType)) {
-        //     console.warn("⚠️ Compatibility rule references unknown data type:", rule);
-        //     return false;
-        //   }
-        // }
-    }
     return true;
 }

package/dist/settings/index.d.ts

@@ -5,7 +5,8 @@
  * preferences with hybrid persistence (localStorage + optional API sync).
  *
  * Theme stores and functions (theme, resolvedTheme, setTheme, toggleTheme,
- * cycleTheme, initializeTheme) are exported from `@d34dman/flowdrop/core`.
+ * cycleTheme, initializeTheme) are exported from `@d34dman/flowdrop/core`
+ * (sourced from settingsStore).
  *
  * @module settings
  *

package/dist/settings/index.js

@@ -5,7 +5,8 @@
  * preferences with hybrid persistence (localStorage + optional API sync).
  *
  * Theme stores and functions (theme, resolvedTheme, setTheme, toggleTheme,
- * cycleTheme, initializeTheme) are exported from `@d34dman/flowdrop/core`.
+ * cycleTheme, initializeTheme) are exported from `@d34dman/flowdrop/core`
+ * (sourced from settingsStore).
  *
  * @module settings
  *

package/dist/stores/interruptStore.d.ts

@@ -6,7 +6,7 @@
  *
  * @module stores/interruptStore
  */
-import type { Interrupt, InterruptStatus } from '../types/interrupt.js';
+import type { Interrupt } from '../types/interrupt.js';
 import { type InterruptState, type TransitionResult } from '../types/interruptState.js';
 /**
  * Extended interrupt with state machine
@@ -40,16 +40,6 @@ export declare const resolvedInterrupts: import("svelte/store").Readable<Interru
  * Derived store to check if any interrupt is currently submitting
  */
 export declare const isAnySubmitting: import("svelte/store").Readable<boolean>;
-/**
- * Legacy derived store for submitting interrupt IDs
- * @deprecated Use interrupt.machineState.status === "submitting" instead
- */
-export declare const submittingInterrupts: import("svelte/store").Readable<Set<string>>;
-/**
- * Legacy derived store for interrupt errors
- * @deprecated Use interrupt.machineState.error instead
- */
-export declare const interruptErrors: import("svelte/store").Readable<Map<string, string>>;
 /**
  * Interrupt store actions for modifying state
  */
@@ -111,30 +101,18 @@ export declare const interruptActions: {
      */
     resetInterrupt: (interruptId: string) => TransitionResult;
     /**
-     * Update an interrupt's status (legacy)
-     * @deprecated Use startSubmit/submitSuccess/submitFailure instead
-     */
-    updateStatus: (interruptId: string, status: InterruptStatus, responseValue?: unknown) => void;
-    /**
-     * Mark an interrupt as resolved with the user's response (legacy)
-     * @deprecated Use startSubmit + submitSuccess instead
+     * Mark an interrupt as resolved with the user's response
+     *
+     * @param interruptId - The interrupt ID
+     * @param value - The resolved value
      */
     resolveInterrupt: (interruptId: string, value: unknown) => void;
     /**
-     * Mark an interrupt as cancelled (legacy)
-     * @deprecated Use startCancel + submitSuccess instead
+     * Mark an interrupt as cancelled
+     *
+     * @param interruptId - The interrupt ID
      */
     cancelInterrupt: (interruptId: string) => void;
-    /**
-     * Set submitting state for an interrupt (legacy)
-     * @deprecated State is automatically managed by startSubmit/submitSuccess
-     */
-    setSubmitting: (interruptId: string, isSubmitting: boolean) => void;
-    /**
-     * Set error for an interrupt (legacy)
-     * @deprecated Use submitFailure() instead
-     */
-    setError: (interruptId: string, error: string | null) => void;
     /**
      * Remove an interrupt from the store
      *

package/dist/stores/interruptStore.js

@@ -70,33 +70,6 @@ export const isAnySubmitting = derived(interrupts, ($interrupts) => {
     }
     return false;
 });
-/**
- * Legacy derived store for submitting interrupt IDs
- * @deprecated Use interrupt.machineState.status === "submitting" instead
- */
-export const submittingInterrupts = derived(interrupts, ($interrupts) => {
-    const submitting = new Set();
-    $interrupts.forEach((interrupt, id) => {
-        if (checkIsSubmitting(interrupt.machineState)) {
-            submitting.add(id);
-        }
-    });
-    return submitting;
-});
-/**
- * Legacy derived store for interrupt errors
- * @deprecated Use interrupt.machineState.error instead
- */
-export const interruptErrors = derived(interrupts, ($interrupts) => {
-    const errors = new Map();
-    $interrupts.forEach((interrupt, id) => {
-        const errorMsg = getErrorMessage(interrupt.machineState);
-        if (errorMsg) {
-            errors.set(id, errorMsg);
-        }
-    });
-    return errors;
-});
 // =========================================================================
 // State Machine Actions
 // =========================================================================
@@ -249,43 +222,22 @@ export const interruptActions = {
     resetInterrupt: (interruptId) => {
         return applyAction(interruptId, { type: 'RESET' });
     },
-    // =========================================================================
-    // Legacy Actions (for backward compatibility)
-    // =========================================================================
-    /**
-     * Update an interrupt's status (legacy)
-     * @deprecated Use startSubmit/submitSuccess/submitFailure instead
-     */
-    updateStatus: (interruptId, status, responseValue) => {
-        // Map legacy status to state machine actions
-        if (status === 'resolved' && responseValue !== undefined) {
-            const submitResult = applyAction(interruptId, { type: 'SUBMIT', value: responseValue });
-            if (submitResult.valid) {
-                applyAction(interruptId, { type: 'SUCCESS' });
-            }
-        }
-        else if (status === 'cancelled') {
-            const cancelResult = applyAction(interruptId, { type: 'CANCEL' });
-            if (cancelResult.valid) {
-                applyAction(interruptId, { type: 'SUCCESS' });
-            }
-        }
-    },
     /**
-     * Mark an interrupt as resolved with the user's response (legacy)
-     * @deprecated Use startSubmit + submitSuccess instead
+     * Mark an interrupt as resolved with the user's response
+     *
+     * @param interruptId - The interrupt ID
+     * @param value - The resolved value
      */
     resolveInterrupt: (interruptId, value) => {
-        // For backward compatibility, immediately resolve
-        // (assumes sync operation or already completed API call)
         const submitResult = applyAction(interruptId, { type: 'SUBMIT', value });
         if (submitResult.valid) {
             applyAction(interruptId, { type: 'SUCCESS' });
         }
     },
     /**
-     * Mark an interrupt as cancelled (legacy)
-     * @deprecated Use startCancel + submitSuccess instead
+     * Mark an interrupt as cancelled
+     *
+     * @param interruptId - The interrupt ID
      */
     cancelInterrupt: (interruptId) => {
         const cancelResult = applyAction(interruptId, { type: 'CANCEL' });
@@ -293,27 +245,6 @@ export const interruptActions = {
             applyAction(interruptId, { type: 'SUCCESS' });
         }
     },
-    /**
-     * Set submitting state for an interrupt (legacy)
-     * @deprecated State is automatically managed by startSubmit/submitSuccess
-     */
-    setSubmitting: (interruptId, isSubmitting) => {
-        // This is now a no-op - state is managed by the state machine
-        // Kept for backward compatibility
-        if (isSubmitting) {
-            console.warn('[InterruptStore] setSubmitting(true) is deprecated. Use startSubmit() instead.');
-        }
-    },
-    /**
-     * Set error for an interrupt (legacy)
-     * @deprecated Use submitFailure() instead
-     */
-    setError: (interruptId, error) => {
-        if (error) {
-            applyAction(interruptId, { type: 'FAILURE', error });
-        }
-        // Clearing error is not directly supported - use retry or reset
-    },
     /**
      * Remove an interrupt from the store
      *

package/dist/stores/portCoordinateStore.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Port Coordinate Store
+ *
+ * General-purpose store that maintains absolute canvas-space coordinates
+ * for all port handles in the workflow. Built from SvelteFlow's internal
+ * handle bounds data combined with FlowDrop port metadata.
+ *
+ * Primary consumers:
+ * - Proximity connect (port-to-port distance instead of node center distance)
+ *
+ * Coordinates are derived from SvelteFlow's InternalNode.internals.handleBounds
+ * which SvelteFlow already maintains for all node types. This avoids replicating
+ * CSS positioning logic and stays automatically accurate.
+ */
+import type { WorkflowNode as WorkflowNodeType, PortCoordinate, PortCoordinateMap } from '../types/index.js';
+import type { InternalNode } from '@xyflow/svelte';
+/** Store holding all port absolute coordinates, keyed by handleId */
+export declare const portCoordinateStore: import("svelte/store").Writable<PortCoordinateMap>;
+/**
+ * Rebuild coordinates for ALL nodes from SvelteFlow internals.
+ * Call on initial workflow load (after render) and after bulk changes.
+ *
+ * @param nodes - All workflow nodes
+ * @param getInternalNode - SvelteFlow's getInternalNode function
+ */
+export declare function rebuildAllPortCoordinates(nodes: WorkflowNodeType[], getInternalNode: (id: string) => InternalNode | undefined): void;
+/**
+ * Update coordinates for a single node (efficient for drag updates).
+ * Only recomputes ports for the specified node.
+ *
+ * @param node - The workflow node to update
+ * @param getInternalNode - SvelteFlow's getInternalNode function
+ */
+export declare function updateNodePortCoordinates(node: WorkflowNodeType, getInternalNode: (id: string) => InternalNode | undefined): void;
+/**
+ * Remove all coordinates for a node (on node delete).
+ *
+ * @param nodeId - ID of the node to remove
+ */
+export declare function removeNodePortCoordinates(nodeId: string): void;
+/**
+ * Get coordinates for a specific handle.
+ *
+ * @param handleId - The handle ID to look up
+ * @returns The port coordinate or undefined if not found
+ */
+export declare function getPortCoordinate(handleId: string): PortCoordinate | undefined;
+/**
+ * Get all coordinates for a specific node.
+ *
+ * @param nodeId - The node ID to look up
+ * @returns Array of port coordinates for the node
+ */
+export declare function getNodePortCoordinates(nodeId: string): PortCoordinate[];
+/**
+ * Get the current snapshot of all port coordinates (non-reactive).
+ *
+ * @returns Current port coordinate map
+ */
+export declare function getPortCoordinateSnapshot(): PortCoordinateMap;

package/dist/stores/portCoordinateStore.js

@@ -0,0 +1,186 @@
+/**
+ * Port Coordinate Store
+ *
+ * General-purpose store that maintains absolute canvas-space coordinates
+ * for all port handles in the workflow. Built from SvelteFlow's internal
+ * handle bounds data combined with FlowDrop port metadata.
+ *
+ * Primary consumers:
+ * - Proximity connect (port-to-port distance instead of node center distance)
+ *
+ * Coordinates are derived from SvelteFlow's InternalNode.internals.handleBounds
+ * which SvelteFlow already maintains for all node types. This avoids replicating
+ * CSS positioning logic and stays automatically accurate.
+ */
+import { writable, get } from 'svelte/store';
+import { ProximityConnectHelper } from '../helpers/proximityConnect.js';
+/** Store holding all port absolute coordinates, keyed by handleId */
+export const portCoordinateStore = writable(new Map());
+/**
+ * Parse a handle ID to extract nodeId, direction, and portId.
+ * Handle ID format: ${nodeId}-${direction}-${portId}
+ *
+ * Note: nodeId itself can contain hyphens, so we match direction
+ * from the known suffixes (-input- or -output-).
+ */
+function parseHandleId(handleId) {
+    // Match the last occurrence of -input- or -output- to handle nodeIds with hyphens
+    const inputMatch = handleId.match(/^(.+)-input-(.+)$/);
+    if (inputMatch) {
+        return { nodeId: inputMatch[1], direction: 'input', portId: inputMatch[2] };
+    }
+    const outputMatch = handleId.match(/^(.+)-output-(.+)$/);
+    if (outputMatch) {
+        return { nodeId: outputMatch[1], direction: 'output', portId: outputMatch[2] };
+    }
+    return null;
+}
+/**
+ * Build a dataType lookup map from a node's ports.
+ * Maps portId → dataType for quick lookup when processing handle bounds.
+ */
+function buildPortDataTypeLookup(node) {
+    const lookup = new Map();
+    const inputs = ProximityConnectHelper.getAllPorts(node, 'input');
+    for (const port of inputs) {
+        lookup.set(`input-${port.id}`, port.dataType);
+    }
+    const outputs = ProximityConnectHelper.getAllPorts(node, 'output');
+    for (const port of outputs) {
+        lookup.set(`output-${port.id}`, port.dataType);
+    }
+    return lookup;
+}
+/**
+ * Compute port coordinates for a single node from SvelteFlow internal data.
+ *
+ * @param node - The workflow node
+ * @param internalNode - SvelteFlow's internal node with handleBounds
+ * @returns Array of PortCoordinate entries for this node
+ */
+function computeNodePortCoordinates(node, internalNode) {
+    const handleBounds = internalNode.internals.handleBounds;
+    if (!handleBounds)
+        return [];
+    const posAbs = internalNode.internals.positionAbsolute;
+    const dataTypeLookup = buildPortDataTypeLookup(node);
+    const coordinates = [];
+    const allHandles = [
+        ...(handleBounds.source ?? []),
+        ...(handleBounds.target ?? [])
+    ];
+    for (const handle of allHandles) {
+        if (!handle.id)
+            continue;
+        const parsed = parseHandleId(handle.id);
+        if (!parsed)
+            continue;
+        const lookupKey = `${parsed.direction}-${parsed.portId}`;
+        const dataType = dataTypeLookup.get(lookupKey);
+        if (!dataType)
+            continue;
+        coordinates.push({
+            x: posAbs.x + handle.x + handle.width / 2,
+            y: posAbs.y + handle.y + handle.height / 2,
+            handleId: handle.id,
+            nodeId: parsed.nodeId,
+            direction: parsed.direction,
+            dataType
+        });
+    }
+    return coordinates;
+}
+/**
+ * Rebuild coordinates for ALL nodes from SvelteFlow internals.
+ * Call on initial workflow load (after render) and after bulk changes.
+ *
+ * @param nodes - All workflow nodes
+ * @param getInternalNode - SvelteFlow's getInternalNode function
+ */
+export function rebuildAllPortCoordinates(nodes, getInternalNode) {
+    const map = new Map();
+    for (const node of nodes) {
+        const internalNode = getInternalNode(node.id);
+        if (!internalNode)
+            continue;
+        const coords = computeNodePortCoordinates(node, internalNode);
+        for (const coord of coords) {
+            map.set(coord.handleId, coord);
+        }
+    }
+    portCoordinateStore.set(map);
+}
+/**
+ * Update coordinates for a single node (efficient for drag updates).
+ * Only recomputes ports for the specified node.
+ *
+ * @param node - The workflow node to update
+ * @param getInternalNode - SvelteFlow's getInternalNode function
+ */
+export function updateNodePortCoordinates(node, getInternalNode) {
+    const internalNode = getInternalNode(node.id);
+    if (!internalNode)
+        return;
+    portCoordinateStore.update((map) => {
+        // Remove old entries for this node
+        for (const [key, coord] of map) {
+            if (coord.nodeId === node.id) {
+                map.delete(key);
+            }
+        }
+        // Add new entries
+        const coords = computeNodePortCoordinates(node, internalNode);
+        for (const coord of coords) {
+            map.set(coord.handleId, coord);
+        }
+        // Return new reference for reactivity
+        return new Map(map);
+    });
+}
+/**
+ * Remove all coordinates for a node (on node delete).
+ *
+ * @param nodeId - ID of the node to remove
+ */
+export function removeNodePortCoordinates(nodeId) {
+    portCoordinateStore.update((map) => {
+        for (const [key, coord] of map) {
+            if (coord.nodeId === nodeId) {
+                map.delete(key);
+            }
+        }
+        return new Map(map);
+    });
+}
+/**
+ * Get coordinates for a specific handle.
+ *
+ * @param handleId - The handle ID to look up
+ * @returns The port coordinate or undefined if not found
+ */
+export function getPortCoordinate(handleId) {
+    return get(portCoordinateStore).get(handleId);
+}
+/**
+ * Get all coordinates for a specific node.
+ *
+ * @param nodeId - The node ID to look up
+ * @returns Array of port coordinates for the node
+ */
+export function getNodePortCoordinates(nodeId) {
+    const result = [];
+    for (const coord of get(portCoordinateStore).values()) {
+        if (coord.nodeId === nodeId) {
+            result.push(coord);
+        }
+    }
+    return result;
+}
+/**
+ * Get the current snapshot of all port coordinates (non-reactive).
+ *
+ * @returns Current port coordinate map
+ */
+export function getPortCoordinateSnapshot() {
+    return get(portCoordinateStore);
+}