@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/packager-tool-4fhgws0x.js

@@ -0,0 +1,757 @@
+import {
+  enableErrorHandlingForErrorEdges,
+  expandHandleIds
+} from "./packager-tool-nq4rcqqg.js";
+import {
+  readFlowWorkflow,
+  writeFlowWorkflow
+} from "./packager-tool-94w17vf8.js";
+import {
+  DEFAULT_LAYOUT_OPTIONS,
+  GRID_SPACING,
+  resolveHeight,
+  resolveWidth,
+  snapToGrid
+} from "./packager-tool-tn5e7wnb.js";
+import {
+  generateNodeVariables
+} from "./packager-tool-vpqyvh4c.js";
+import {
+  __require,
+  __toESM
+} from "./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-core/dist/layout.js
+function analyzeArtifactConnections(edges, nodePortsMap) {
+  const groupMap = /* @__PURE__ */ new Map;
+  const artifactNodeIds = /* @__PURE__ */ new Set;
+  for (const edge of edges) {
+    const sourceHandle = edge.sourceHandle;
+    if (!sourceHandle)
+      continue;
+    const sourcePorts = nodePortsMap.get(edge.source);
+    if (!sourcePorts)
+      continue;
+    const port = sourcePorts.find((p) => p.id === sourceHandle);
+    if (!port || port.side !== "NORTH" && port.side !== "SOUTH")
+      continue;
+    const parentId = edge.source;
+    const artifactId = edge.target;
+    artifactNodeIds.add(artifactId);
+    let parentGroups = groupMap.get(parentId);
+    if (!parentGroups) {
+      parentGroups = /* @__PURE__ */ new Map;
+      groupMap.set(parentId, parentGroups);
+    }
+    let group = parentGroups.get(sourceHandle);
+    if (!group) {
+      group = { side: port.side, nodeIds: [], artifactHandleMap: /* @__PURE__ */ new Map };
+      parentGroups.set(sourceHandle, group);
+    }
+    if (!group.nodeIds.includes(artifactId)) {
+      group.nodeIds.push(artifactId);
+      if (edge.targetHandle) {
+        group.artifactHandleMap.set(artifactId, edge.targetHandle);
+      }
+    }
+  }
+  const artifactGroups = [];
+  for (const [parentId, handleMap] of groupMap) {
+    const parentPorts = nodePortsMap.get(parentId) ?? [];
+    for (const [sourceHandle, group] of handleMap) {
+      const parentPort = parentPorts.find((p) => p.id === sourceHandle);
+      artifactGroups.push({
+        parentId,
+        side: group.side,
+        sourceHandle,
+        parentPortIndex: parentPort?.index ?? 0,
+        artifactNodeIds: [...group.nodeIds],
+        artifactToHandle: group.artifactHandleMap
+      });
+    }
+  }
+  return { artifactGroups, artifactNodeIds };
+}
+function buildArtifactParentWrappers(artifactGroups) {
+  const wrapperMap = /* @__PURE__ */ new Map;
+  for (const group of artifactGroups) {
+    let wrapper = wrapperMap.get(group.parentId);
+    if (!wrapper) {
+      wrapper = { parentId: group.parentId, northGroups: [], southGroups: [] };
+      wrapperMap.set(group.parentId, wrapper);
+    }
+    if (group.side === "NORTH")
+      wrapper.northGroups.push(group);
+    else
+      wrapper.southGroups.push(group);
+  }
+  for (const wrapper of wrapperMap.values()) {
+    wrapper.northGroups.sort((a, b) => a.parentPortIndex - b.parentPortIndex);
+    wrapper.southGroups.sort((a, b) => a.parentPortIndex - b.parentPortIndex);
+  }
+  return Array.from(wrapperMap.values());
+}
+var ARTIFACT_GROUP_SPACING = 96;
+var ARTIFACT_HORIZONTAL_SPACING = ARTIFACT_GROUP_SPACING / 2;
+var edgeNodeClearance = (options) => snapToGrid(options.layerSpacing / 2);
+var EDGE_EDGE_CLEARANCE_PX = GRID_SPACING;
+var GRID_PADDING = `[top=${GRID_SPACING},left=${GRID_SPACING},bottom=${GRID_SPACING},right=${GRID_SPACING}]`;
+function makeGroupId(group) {
+  return `${group.parentId}__${group.sourceHandle}_group`;
+}
+function computeElkPortIndices(ports) {
+  const bySide = /* @__PURE__ */ new Map;
+  for (const p of ports) {
+    if (!bySide.has(p.side))
+      bySide.set(p.side, []);
+    bySide.get(p.side).push(p);
+  }
+  const result = /* @__PURE__ */ new Map;
+  for (const [side, sidePorts] of bySide) {
+    const sorted = [...sidePorts].sort((a, b) => a.index - b.index);
+    const reverse = side === "SOUTH" || side === "WEST";
+    sorted.forEach((p, i) => {
+      result.set(p.id, reverse ? sorted.length - 1 - i : i);
+    });
+  }
+  return result;
+}
+var warmElkLayoutChunk = () => import("./elk.bundled-vpsbxz0p.js").then((m)=>__toESM(m.default,1));
+var ElkLayoutEngine = class {
+  constructor(elk) {
+    this.elkPromise = null;
+    if (elk)
+      this.elkPromise = Promise.resolve(elk);
+  }
+  getElk() {
+    if (!this.elkPromise) {
+      this.elkPromise = warmElkLayoutChunk().then((m) => new m.default);
+    }
+    return this.elkPromise;
+  }
+  async layoutHierarchical(root) {
+    const elk = await this.getElk();
+    return elk.layout(root);
+  }
+  async layout(nodes, edges, options, resolveNodePorts) {
+    const startTime = performance.now();
+    const nodePortsMap = this.collectPorts(nodes, options, resolveNodePorts);
+    const { artifactGroups, artifactNodeIds } = analyzeArtifactConnections(edges, nodePortsMap);
+    const graph = this.buildHierarchicalGraph(nodes, edges, nodePortsMap, artifactGroups, artifactNodeIds, options);
+    const elk = await this.getElk();
+    const layouted = await elk.layout(graph);
+    const updatedNodes = this.extractNodePositions(nodes, layouted);
+    const edgeWaypoints = this.extractEdgeWaypoints(layouted, new Set(edges.map((e) => e.id)));
+    const endTime = performance.now();
+    const metrics = this.calculateMetrics(layouted, endTime - startTime);
+    return { nodes: updatedNodes, edgeWaypoints, metrics };
+  }
+  collectPorts(nodes, options, resolveNodePorts) {
+    const nodePortsMap = /* @__PURE__ */ new Map;
+    for (const node of nodes) {
+      const ports = resolveNodePorts(node, options);
+      if (ports.length > 0) {
+        nodePortsMap.set(node.id, ports);
+      }
+    }
+    return nodePortsMap;
+  }
+  buildHierarchicalGraph(nodes, edges, nodePortsMap, artifactGroups, artifactNodeIds, options) {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const parentWrappers = buildArtifactParentWrappers(artifactGroups);
+    const wrappedParentIds = new Set(parentWrappers.map((w) => w.parentId));
+    const rootChildren = [];
+    for (const node of nodes) {
+      if (artifactNodeIds.has(node.id) || wrappedParentIds.has(node.id))
+        continue;
+      rootChildren.push(this.createElkNode(node, nodePortsMap));
+    }
+    for (const wrapper of parentWrappers) {
+      const parentNode = nodeMap.get(wrapper.parentId);
+      rootChildren.push(this.createWrapperNode(wrapper, parentNode, nodePortsMap, nodeMap, options));
+    }
+    const elkEdges = this.buildEdges(edges, wrappedParentIds, artifactNodeIds, nodePortsMap);
+    return {
+      id: "root",
+      layoutOptions: this.getLayoutOptions(options),
+      children: rootChildren,
+      edges: elkEdges
+    };
+  }
+  createElkNode(node, nodePortsMap) {
+    const ports = nodePortsMap.get(node.id) ?? [];
+    const elkIndices = computeElkPortIndices(ports);
+    const elkPorts = ports.map((port) => ({
+      id: `${node.id}_${port.id}`,
+      layoutOptions: { "port.side": port.side, "port.index": (elkIndices.get(port.id) ?? port.index).toString() }
+    }));
+    return {
+      id: node.id,
+      width: resolveWidth(node),
+      height: resolveHeight(node),
+      ports: elkPorts.length > 0 ? elkPorts : undefined,
+      layoutOptions: elkPorts.length > 0 ? { portConstraints: "FIXED_ORDER" } : undefined
+    };
+  }
+  createWrapperNode(wrapper, parentNode, nodePortsMap, nodeMap, options) {
+    const wrapperId = `${wrapper.parentId}_wrapper`;
+    const wrapperChildren = [];
+    for (const group of wrapper.northGroups) {
+      const child = this.createGroupNode(group, nodePortsMap, nodeMap, options);
+      child.layoutOptions = { ...child.layoutOptions, "elk.partitioning.partition": "0" };
+      wrapperChildren.push(child);
+    }
+    const parentPorts = nodePortsMap.get(wrapper.parentId) ?? [];
+    const parentElkIndices = computeElkPortIndices(parentPorts);
+    const parentElkPorts = parentPorts.map((port) => ({
+      id: `${wrapper.parentId}_${port.id}`,
+      layoutOptions: { "port.side": port.side, "port.index": (parentElkIndices.get(port.id) ?? port.index).toString() }
+    }));
+    wrapperChildren.push({
+      id: wrapper.parentId,
+      width: resolveWidth(parentNode),
+      height: resolveHeight(parentNode),
+      ports: parentElkPorts.length > 0 ? parentElkPorts : undefined,
+      layoutOptions: {
+        ...parentElkPorts.length > 0 ? { portConstraints: "FIXED_ORDER" } : {},
+        "elk.partitioning.partition": "1"
+      }
+    });
+    for (const group of wrapper.southGroups) {
+      const child = this.createGroupNode(group, nodePortsMap, nodeMap, options);
+      child.layoutOptions = { ...child.layoutOptions, "elk.partitioning.partition": "2" };
+      wrapperChildren.push(child);
+    }
+    const wrapperPorts = parentPorts.filter((p) => p.side === "WEST" || p.side === "EAST").map((port) => ({
+      id: `${wrapperId}_${port.id}`,
+      layoutOptions: { "port.side": port.side, "port.index": (parentElkIndices.get(port.id) ?? port.index).toString() }
+    }));
+    const internalEdges = [];
+    for (const group of [...wrapper.northGroups, ...wrapper.southGroups]) {
+      const groupId = makeGroupId(group);
+      internalEdges.push({
+        id: `internal_${wrapper.parentId}_${group.sourceHandle}_to_${groupId}`,
+        sources: [`${wrapper.parentId}_${group.sourceHandle}`],
+        targets: [`${groupId}_port`]
+      });
+    }
+    return {
+      id: wrapperId,
+      children: wrapperChildren,
+      edges: internalEdges.length > 0 ? internalEdges : undefined,
+      ports: wrapperPorts.length > 0 ? wrapperPorts : undefined,
+      layoutOptions: {
+        "elk.algorithm": "layered",
+        "elk.direction": "DOWN",
+        "elk.spacing.nodeNode": ARTIFACT_GROUP_SPACING.toString(),
+        "elk.layered.spacing.nodeNodeBetweenLayers": ARTIFACT_GROUP_SPACING.toString(),
+        "elk.padding": "[top=0,left=0,bottom=0,right=0]",
+        portConstraints: "FIXED_SIDE",
+        "elk.alignment": "CENTER",
+        "elk.layered.nodePlacement.strategy": "BRANDES_KOEPF",
+        "elk.layered.nodePlacement.bk.fixedAlignment": "BALANCED",
+        "elk.layered.nodePlacement.bk.edgeStraightening": "IMPROVE_STRAIGHTNESS",
+        "elk.partitioning.activate": "true"
+      }
+    };
+  }
+  createGroupNode(group, nodePortsMap, nodeMap, _options) {
+    const groupId = makeGroupId(group);
+    const children = group.artifactNodeIds.map((artifactId, index) => {
+      const node = nodeMap.get(artifactId);
+      const ports = nodePortsMap.get(artifactId) ?? [];
+      const elkIndices = computeElkPortIndices(ports);
+      const elkPorts = ports.map((port) => ({
+        id: `${artifactId}_${port.id}`,
+        layoutOptions: { "port.side": port.side, "port.index": (elkIndices.get(port.id) ?? port.index).toString() }
+      }));
+      if (index > 0) {
+        elkPorts.push({ id: `${artifactId}_chain_in`, layoutOptions: { "port.side": "WEST", "port.index": "100" } });
+      }
+      if (index < group.artifactNodeIds.length - 1) {
+        elkPorts.push({ id: `${artifactId}_chain_out`, layoutOptions: { "port.side": "EAST", "port.index": "100" } });
+      }
+      return {
+        id: artifactId,
+        width: node ? resolveWidth(node) : 96,
+        height: node ? resolveHeight(node) : 96,
+        ports: elkPorts.length > 0 ? elkPorts : undefined,
+        layoutOptions: { portConstraints: "FIXED_SIDE" }
+      };
+    });
+    const chainEdges = [];
+    for (let i = 0;i < group.artifactNodeIds.length - 1; i++) {
+      const sourceId = group.artifactNodeIds[i];
+      const targetId = group.artifactNodeIds[i + 1];
+      chainEdges.push({
+        id: `${groupId}_chain_${i}`,
+        sources: [`${sourceId}_chain_out`],
+        targets: [`${targetId}_chain_in`]
+      });
+    }
+    const groupPort = {
+      id: `${groupId}_port`,
+      layoutOptions: {
+        "port.side": group.side === "NORTH" ? "SOUTH" : "NORTH",
+        "port.index": "0"
+      }
+    };
+    return {
+      id: groupId,
+      children,
+      edges: chainEdges.length > 0 ? chainEdges : undefined,
+      ports: [groupPort],
+      layoutOptions: {
+        "elk.algorithm": "layered",
+        "elk.direction": "RIGHT",
+        "elk.spacing.nodeNode": ARTIFACT_HORIZONTAL_SPACING.toString(),
+        "elk.layered.spacing.nodeNodeBetweenLayers": ARTIFACT_HORIZONTAL_SPACING.toString(),
+        "elk.padding": "[top=0,left=0,bottom=0,right=0]",
+        portConstraints: "FIXED_SIDE"
+      }
+    };
+  }
+  buildEdges(edges, wrappedParentIds, artifactNodeIds, nodePortsMap) {
+    const elkEdges = [];
+    for (const edge of edges) {
+      const sourceHandle = edge.sourceHandle;
+      const targetHandle = edge.targetHandle;
+      if (artifactNodeIds.has(edge.target))
+        continue;
+      let sourceRef;
+      if (wrappedParentIds.has(edge.source) && sourceHandle) {
+        sourceRef = `${edge.source}_wrapper_${sourceHandle}`;
+      } else if (sourceHandle && this.hasPort(nodePortsMap, edge.source, sourceHandle)) {
+        sourceRef = `${edge.source}_${sourceHandle}`;
+      } else {
+        sourceRef = edge.source;
+      }
+      let targetRef;
+      if (wrappedParentIds.has(edge.target) && targetHandle) {
+        targetRef = `${edge.target}_wrapper_${targetHandle}`;
+      } else if (targetHandle && this.hasPort(nodePortsMap, edge.target, targetHandle)) {
+        targetRef = `${edge.target}_${targetHandle}`;
+      } else {
+        targetRef = edge.target;
+      }
+      elkEdges.push({ id: edge.id, sources: [sourceRef], targets: [targetRef] });
+    }
+    return elkEdges;
+  }
+  hasPort(nodePortsMap, nodeId, handleId) {
+    const ports = nodePortsMap.get(nodeId);
+    return ports != null && ports.some((p) => p.id === handleId);
+  }
+  extractNodePositions(nodes, layouted) {
+    const nodePositions = /* @__PURE__ */ new Map;
+    for (const child of layouted.children ?? []) {
+      if (child.id.endsWith("_wrapper")) {
+        const wrapperX = child.x ?? 0;
+        const wrapperY = child.y ?? 0;
+        for (const wrapperChild of child.children ?? []) {
+          if (wrapperChild.id.endsWith("_group")) {
+            const groupX = wrapperX + (wrapperChild.x ?? 0);
+            const groupY = wrapperY + (wrapperChild.y ?? 0);
+            for (const artifact of wrapperChild.children ?? []) {
+              nodePositions.set(artifact.id, {
+                x: snapToGrid(groupX + (artifact.x ?? 0)),
+                y: snapToGrid(groupY + (artifact.y ?? 0))
+              });
+            }
+          } else {
+            nodePositions.set(wrapperChild.id, {
+              x: snapToGrid(wrapperX + (wrapperChild.x ?? 0)),
+              y: snapToGrid(wrapperY + (wrapperChild.y ?? 0))
+            });
+          }
+        }
+      } else {
+        nodePositions.set(child.id, {
+          x: snapToGrid(child.x ?? 0),
+          y: snapToGrid(child.y ?? 0)
+        });
+      }
+    }
+    return nodes.map((node) => {
+      const pos = nodePositions.get(node.id);
+      if (!pos)
+        return node;
+      return { ...node, position: { x: pos.x, y: pos.y } };
+    });
+  }
+  extractEdgeWaypoints(root, realEdgeIds) {
+    const result = /* @__PURE__ */ new Map;
+    for (const edge of root.edges ?? []) {
+      if (!realEdgeIds.has(edge.id))
+        continue;
+      const points = (edge.sections ?? []).flatMap((s) => s.bendPoints ?? []).map((p) => ({ x: snapToGrid(p.x), y: snapToGrid(p.y) }));
+      if (points.length > 0)
+        result.set(edge.id, points);
+    }
+    return result;
+  }
+  getLayoutOptions(options) {
+    const opts = {
+      "elk.algorithm": options.algorithm,
+      "elk.direction": options.direction,
+      "elk.spacing.nodeNode": options.nodeSpacing.toString(),
+      "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
+      "elk.padding": GRID_PADDING
+    };
+    switch (options.algorithm) {
+      case "layered":
+        opts["elk.layered.spacing.nodeNodeBetweenLayers"] = options.layerSpacing.toString();
+        opts["elk.layered.nodePlacement.strategy"] = "NETWORK_SIMPLEX";
+        opts["elk.layered.layering.strategy"] = "NETWORK_SIMPLEX";
+        if (options.minimizeCrossings) {
+          opts["elk.layered.crossingMinimization.strategy"] = "LAYER_SWEEP";
+        }
+        opts["elk.layered.cycleBreaking.strategy"] = "GREEDY_MODEL_ORDER";
+        opts["elk.spacing.edgeNode"] = options.nodeSpacing.toString();
+        opts["elk.spacing.edgeEdge"] = EDGE_EDGE_CLEARANCE_PX.toString();
+        opts["elk.layered.spacing.edgeNodeBetweenLayers"] = edgeNodeClearance(options).toString();
+        opts["elk.edgeRouting"] = "ORTHOGONAL";
+        break;
+      case "mrtree":
+        opts["elk.spacing.nodeNode"] = options.nodeSpacing.toString();
+        break;
+    }
+    return opts;
+  }
+  calculateMetrics(elkGraph, executionTime) {
+    const children = elkGraph.children || [];
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const node of children) {
+      const x = node.x || 0;
+      const y = node.y || 0;
+      const width = node.width || 0;
+      const height = node.height || 0;
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      maxX = Math.max(maxX, x + width);
+      maxY = Math.max(maxY, y + height);
+    }
+    return { totalWidth: maxX - minX, totalHeight: maxY - minY, executionTime };
+  }
+};
+
+// src/services/tidy-service.ts
+var COLLAPSED_NODE_SIZE = 96;
+var EXPANDED_RECTANGLE_WIDTH = 288;
+var CONTAINER_SIZE = { width: 560, height: 320 };
+function expandedSizeForShape(shape) {
+  if (shape === "container") {
+    return { ...CONTAINER_SIZE };
+  }
+  return {
+    width: shape === "rectangle" ? EXPANDED_RECTANGLE_WIDTH : COLLAPSED_NODE_SIZE,
+    height: COLLAPSED_NODE_SIZE
+  };
+}
+var UI_ONLY_NODE_TYPES = new Set(["stickyNote"]);
+function identifyArtifactChildIds(edges, portResolver, nodes) {
+  const ids = new Set;
+  for (const edge of edges) {
+    if (!edge.sourceHandle)
+      continue;
+    const sourceNode = nodes.find((n) => n.id === edge.source);
+    if (!sourceNode)
+      continue;
+    const ports = portResolver(sourceNode, DEFAULT_LAYOUT_OPTIONS);
+    const port = ports.find((p) => p.id === edge.sourceHandle);
+    if (port && (port.side === "NORTH" || port.side === "SOUTH")) {
+      ids.add(edge.target);
+    }
+  }
+  return ids;
+}
+function collectArtifactDescendants(startIds, edges, artifactChildIds) {
+  const result = new Set;
+  const queue = [...startIds];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id)
+      break;
+    for (const edge of edges) {
+      if (edge.source === id && artifactChildIds.has(edge.target) && !result.has(edge.target)) {
+        result.add(edge.target);
+        queue.push(edge.target);
+      }
+    }
+  }
+  return result;
+}
+function propagateHiddenArtifactPositions(layoutedNodes, preLayoutPositions, hiddenNodes, edges, artifactChildIds) {
+  const layoutPositionMap = new Map(layoutedNodes.map((n) => [n.id, n.position]));
+  const updates = [];
+  const collapsedLayouted = layoutedNodes.filter((n) => n.data?.ui?.isCollapsed);
+  const updatedIds = new Set;
+  for (const collapsed of collapsedLayouted) {
+    const oldPos = preLayoutPositions.get(collapsed.id);
+    if (!oldPos)
+      continue;
+    const dx = collapsed.position.x - oldPos.x;
+    const dy = collapsed.position.y - oldPos.y;
+    if (Math.abs(dx) < 1 && Math.abs(dy) < 1)
+      continue;
+    const descendants = collectArtifactDescendants(new Set([collapsed.id]), edges, artifactChildIds);
+    for (const childId of descendants) {
+      if (layoutPositionMap.has(childId))
+        continue;
+      if (updatedIds.has(childId))
+        continue;
+      const child = hiddenNodes.find((n) => n.id === childId);
+      if (!child)
+        continue;
+      updatedIds.add(childId);
+      updates.push({
+        ...child,
+        position: {
+          x: snapToGrid((child.position.x || 0) + dx),
+          y: snapToGrid((child.position.y || 0) + dy)
+        }
+      });
+    }
+  }
+  return updates;
+}
+function positionToSide(position) {
+  switch (position) {
+    case "left":
+      return "WEST";
+    case "right":
+      return "EAST";
+    case "top":
+      return "NORTH";
+    case "bottom":
+    case "bottom-left":
+    case "bottom-right":
+      return "SOUTH";
+    default:
+      return "EAST";
+  }
+}
+function buildPortResolver(definitions) {
+  const defMap = new Map;
+  for (const raw of definitions) {
+    if (raw != null && typeof raw === "object" && "nodeType" in raw && "version" in raw) {
+      const def = raw;
+      defMap.set(`${def.nodeType}:${def.version}`, def);
+    }
+  }
+  return (layoutNode) => {
+    const nodeInstance = layoutNode.data;
+    if (!nodeInstance) {
+      return defaultPorts();
+    }
+    const def = defMap.get(`${nodeInstance.type}:${nodeInstance.typeVersion}`);
+    if (!def?.handleConfiguration?.length) {
+      return defaultPorts();
+    }
+    const ports = [];
+    let portIndex = 0;
+    for (const group of def.handleConfiguration) {
+      const side = positionToSide(group.position);
+      for (const handle of group.handles) {
+        const expandedIds = expandHandleIds(handle, nodeInstance);
+        for (const id of expandedIds) {
+          ports.push({ id, side, index: portIndex++ });
+        }
+      }
+    }
+    return ports.length > 0 ? ports : defaultPorts();
+  };
+}
+function defaultPorts() {
+  return [
+    { id: "input", side: "WEST", index: 0 },
+    { id: "output", side: "EAST", index: 1 }
+  ];
+}
+function buildShapeResolver(definitions) {
+  const byKey = new Map;
+  const byType = new Map;
+  for (const raw of definitions) {
+    if (raw != null && typeof raw === "object" && "nodeType" in raw) {
+      const def = raw;
+      const shape = def.display?.shape;
+      if (def.version !== undefined) {
+        byKey.set(`${def.nodeType}:${def.version}`, shape);
+      }
+      if (!byType.has(def.nodeType)) {
+        byType.set(def.nodeType, shape);
+      }
+    }
+  }
+  return (node) => {
+    const instanceShape = node.display?.shape;
+    if (instanceShape) {
+      return instanceShape;
+    }
+    const keyed = byKey.get(`${node.type}:${node.typeVersion}`);
+    return keyed ?? byType.get(node.type);
+  };
+}
+function nodesToLayoutNodes(nodes, shapeOf) {
+  return nodes.map((node) => {
+    const size = UI_ONLY_NODE_TYPES.has(node.type) ? node.ui.size ?? {
+      width: COLLAPSED_NODE_SIZE,
+      height: COLLAPSED_NODE_SIZE
+    } : expandedSizeForShape(shapeOf(node));
+    return {
+      id: node.id,
+      position: { ...node.ui.position },
+      width: size.width,
+      height: size.height,
+      type: node.type,
+      data: node
+    };
+  });
+}
+function edgesToLayoutEdges(edges) {
+  return edges.map((edge) => ({
+    id: edge.id,
+    source: edge.sourceNodeId,
+    target: edge.targetNodeId,
+    sourceHandle: edge.sourcePort,
+    targetHandle: edge.targetPort
+  }));
+}
+function applyLayoutToNodes(nodes, layoutedNodes, shapeOf) {
+  const positionMap = new Map(layoutedNodes.map((n) => [n.id, n.position]));
+  let repositioned = 0;
+  let resized = 0;
+  for (const node of nodes) {
+    const newPos = positionMap.get(node.id);
+    if (!newPos)
+      continue;
+    const oldX = node.ui.position.x;
+    const oldY = node.ui.position.y;
+    if (oldX !== newPos.x || oldY !== newPos.y) {
+      node.ui.position = { x: newPos.x, y: newPos.y };
+      repositioned++;
+    }
+    if (UI_ONLY_NODE_TYPES.has(node.type)) {
+      continue;
+    }
+    const targetSize = expandedSizeForShape(shapeOf(node));
+    const currentSize = node.ui.size;
+    const sizeNeedsUpdate = currentSize?.width !== targetSize.width || currentSize?.height !== targetSize.height;
+    if (sizeNeedsUpdate) {
+      node.ui.size = targetSize;
+      resized++;
+    }
+  }
+  return { repositioned, resized };
+}
+async function tidyNodesAndEdges(engine, nodes, edges, portResolver, shapeOf) {
+  if (nodes.length === 0) {
+    return { repositioned: 0, resized: 0 };
+  }
+  const allNodes = nodesToLayoutNodes(nodes, shapeOf);
+  const allEdges = edgesToLayoutEdges(edges);
+  const artifactChildIds = identifyArtifactChildIds(allEdges, portResolver, allNodes);
+  const collapsedIds = new Set(allNodes.filter((n) => n.data?.ui?.isCollapsed).map((n) => n.id));
+  const hiddenIds = collectArtifactDescendants(collapsedIds, allEdges, artifactChildIds);
+  const layoutNodes = allNodes.filter((n) => !hiddenIds.has(n.id));
+  const layoutEdges = allEdges.filter((e) => !hiddenIds.has(e.source) && !hiddenIds.has(e.target));
+  const hiddenNodes = allNodes.filter((n) => hiddenIds.has(n.id));
+  if (layoutNodes.length === 0) {
+    return { repositioned: 0, resized: 0 };
+  }
+  const preLayoutPositions = new Map(layoutNodes.map((n) => [n.id, { ...n.position }]));
+  const leftmostNode = layoutNodes.reduce((left, node) => node.position.x < left.position.x ? node : left);
+  const originalLeftX = leftmostNode.position.x;
+  const originalLeftY = leftmostNode.position.y;
+  const { nodes: layoutedNodes } = await engine.layout(layoutNodes, layoutEdges, { ...DEFAULT_LAYOUT_OPTIONS, animate: false }, portResolver);
+  const layoutedLeftmost = layoutedNodes.find((n) => n.id === leftmostNode.id);
+  if (layoutedLeftmost) {
+    const offsetX = originalLeftX - layoutedLeftmost.position.x;
+    const offsetY = originalLeftY - layoutedLeftmost.position.y;
+    for (const node of layoutedNodes) {
+      node.position.x = snapToGrid(node.position.x + offsetX);
+      node.position.y = snapToGrid(node.position.y + offsetY);
+    }
+  }
+  const hiddenUpdates = propagateHiddenArtifactPositions(layoutedNodes, preLayoutPositions, hiddenNodes, allEdges, artifactChildIds);
+  const allUpdated = [...layoutedNodes, ...hiddenUpdates];
+  return applyLayoutToNodes(nodes, allUpdated, shapeOf);
+}
+async function tidyFlow(filePath) {
+  const { workflow, refMap } = await readFlowWorkflow(filePath);
+  const engine = new ElkLayoutEngine;
+  const portResolver = buildPortResolver(workflow.definitions);
+  const shapeResolver = buildShapeResolver(workflow.definitions);
+  const top = await tidyNodesAndEdges(engine, workflow.nodes, workflow.edges, portResolver, shapeResolver);
+  let nodeCount = workflow.nodes.length;
+  let edgeCount = workflow.edges.length;
+  let nodesRepositioned = top.repositioned;
+  let nodesResized = top.resized;
+  let subflowsTidied = 0;
+  if (workflow.subflows) {
+    const subflows = workflow.subflows;
+    for (const subflow of Object.values(subflows)) {
+      const sub = await tidyNodesAndEdges(engine, subflow.nodes, subflow.edges, portResolver, shapeResolver);
+      nodeCount += subflow.nodes.length;
+      edgeCount += subflow.edges.length;
+      nodesRepositioned += sub.repositioned;
+      nodesResized += sub.resized;
+      subflowsTidied += 1;
+    }
+  }
+  enableErrorHandlingForErrorEdges(workflow.nodes, workflow.edges);
+  if (workflow.subflows) {
+    const subflows = workflow.subflows;
+    for (const subflow of Object.values(subflows)) {
+      enableErrorHandlingForErrorEdges(subflow.nodes, subflow.edges);
+    }
+  }
+  if (nodeCount === 0) {
+    return {
+      nodeCount: 0,
+      edgeCount: 0,
+      nodesRepositioned: 0,
+      nodesResized: 0,
+      subflowsTidied: 0,
+      variableCount: 0
+    };
+  }
+  const variableCount = regenerateNodeVariables(workflow);
+  await writeFlowWorkflow(filePath, workflow, refMap);
+  return {
+    nodeCount,
+    edgeCount,
+    nodesRepositioned,
+    nodesResized,
+    subflowsTidied,
+    variableCount
+  };
+}
+function regenerateNodeVariables(workflow) {
+  const definitions = workflow.definitions ?? [];
+  const topNodeVars = generateNodeVariables(workflow.nodes, definitions);
+  workflow.variables = {
+    ...workflow.variables ?? {},
+    nodes: topNodeVars
+  };
+  let total = topNodeVars.length;
+  if (workflow.subflows) {
+    const subflows = workflow.subflows;
+    for (const subflow of Object.values(subflows)) {
+      const subNodeVars = generateNodeVariables(subflow.nodes, definitions);
+      subflow.variables = {
+        ...subflow.variables ?? {},
+        nodes: subNodeVars
+      };
+      total += subNodeVars.length;
+    }
+  }
+  return total;
+}
+
+export { UI_ONLY_NODE_TYPES, tidyFlow };
+
+//# debugId=61782660AAF1BE9364756E2164756E21