@elabs-ai/components-flow 4.2.0 → 5.0.0

package/dist/chunk-TEZ3OXAY.js

@@ -0,0 +1,63 @@
+"use client";
+
+// src/flow-self-loop-edge/self-loop-geometry.ts
+var DEFAULT_LOOP_RADIUS = 28;
+var CONTROL_REACH_X = 1.2;
+var CONTROL_REACH_Y = 2.4;
+var APEX_FACTOR = 3 / 4 * CONTROL_REACH_Y;
+function selfLoopPath(anchor, loopRadius) {
+  const cx = Number.isFinite(anchor.centerX) ? anchor.centerX : 0;
+  const ay = Number.isFinite(anchor.topY) ? anchor.topY : 0;
+  const r = Number.isFinite(loopRadius) && loopRadius > 0 ? loopRadius : DEFAULT_LOOP_RADIUS;
+  const startX = cx + r;
+  const endX = cx - r;
+  const controlY = ay - r * CONTROL_REACH_Y;
+  return {
+    path: `M ${startX},${ay} C ${startX + r * CONTROL_REACH_X},${controlY} ${endX - r * CONTROL_REACH_X},${controlY} ${endX},${ay}`,
+    labelX: cx,
+    labelY: ay - r * APEX_FACTOR
+  };
+}
+function outward(x, y, centerX, centerY, fallback) {
+  const dx = x - centerX;
+  const dy = y - centerY;
+  const length = Math.hypot(dx, dy);
+  if (!Number.isFinite(length) || length < 1e-6) return fallback;
+  return [dx / length, dy / length];
+}
+function selfLoopHandleArc(anchor, loopRadius) {
+  const num = (value) => Number.isFinite(value) ? value : 0;
+  const sx = num(anchor.sourceX);
+  const sy = num(anchor.sourceY);
+  const tx = num(anchor.targetX);
+  const ty = num(anchor.targetY);
+  const cx = num(anchor.centerX);
+  const cy = num(anchor.centerY);
+  const width = Math.max(0, num(anchor.width));
+  const height = Math.max(0, num(anchor.height));
+  const r = Number.isFinite(loopRadius) && loopRadius > 0 ? loopRadius : DEFAULT_LOOP_RADIUS;
+  const [osx, osy] = outward(sx, sy, cx, cy, [0, 1]);
+  const [otx, oty] = outward(tx, ty, cx, cy, [-osx, -osy]);
+  const lx = osy;
+  const ly = -osx;
+  const clearance = Math.abs(lx) * (width / 2) + Math.abs(ly) * (height / 2) + r;
+  const reach = 4 / 3 * clearance;
+  const c1x = sx + osx * r + lx * reach;
+  const c1y = sy + osy * r + ly * reach;
+  const c2x = tx + otx * r + lx * reach;
+  const c2y = ty + oty * r + ly * reach;
+  return {
+    path: `M ${sx},${sy} C ${c1x},${c1y} ${c2x},${c2y} ${tx},${ty}`,
+    // A cubic's midpoint is (P0 + 3·C1 + 3·C2 + P3) / 8 — the arc's apex, which `reach`
+    // above places `loopRadius` clear of the card, so the label sits off the node.
+    labelX: (sx + 3 * c1x + 3 * c2x + tx) / 8,
+    labelY: (sy + 3 * c1y + 3 * c2y + ty) / 8
+  };
+}
+
+export {
+  DEFAULT_LOOP_RADIUS,
+  selfLoopPath,
+  selfLoopHandleArc
+};
+//# sourceMappingURL=chunk-TEZ3OXAY.js.map

package/dist/chunk-TEZ3OXAY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/flow-self-loop-edge/self-loop-geometry.ts"],"sourcesContent":["/**\n * self-loop-geometry — pure, framework-free arc math for a self-referencing edge.\n *\n * Kept out of the component (and out of React) so the loop's shape can be\n * unit-tested without a canvas, and so a sibling that needs the same apex\n * point (a legend, an overlay, a screenshot harness) can compute it directly.\n */\n\n/** Default arc radius, in px. A loop this size clears `FlowNode`'s header without dominating it. */\nexport const DEFAULT_LOOP_RADIUS = 28;\n\n/**\n * How far the cubic's control points reach sideways and upwards, as multiples\n * of `loopRadius`. Tuned so the arc reads as a closed loop rather than a bump:\n * the horizontal reach opens the throat of the loop, the vertical reach sets\n * its height.\n */\nconst CONTROL_REACH_X = 1.2;\nconst CONTROL_REACH_Y = 2.4;\n/** A symmetric cubic's midpoint sits at 3/4 of its control-point height — see `selfLoopPath`. */\nconst APEX_FACTOR = (3 / 4) * CONTROL_REACH_Y;\n\n/** The box a self-loop is drawn above. Matches a React Flow `InternalNode` structurally. */\nexport interface SelfLoopAnchor {\n  /** Horizontal centre of the node the loop belongs to. */\n  centerX: number;\n  /** Top edge of that node — the loop is drawn above this line. */\n  topY: number;\n}\n\nexport interface SelfLoopPath {\n  /** SVG `d` for the arc. */\n  path: string;\n  /** Where a label belongs: the arc's apex. */\n  labelX: number;\n  labelY: number;\n}\n\n/**\n * A cubic arc that leaves the node's top-RIGHT, bulges up over the node, and\n * re-enters at its top-LEFT — the conventional \"this step repeated\" mark in a\n * process map, and a SHAPE rather than a colour, so it survives greyscale.\n *\n * The curve is symmetric about `centerX`, which puts its `t = 0.5` midpoint\n * exactly at `(centerX, topY - APEX_FACTOR × loopRadius)` — the apex the label\n * is anchored to. Never returns `NaN`: a non-finite input falls back to `0`\n * and a non-positive radius falls back to the default.\n */\nexport function selfLoopPath(anchor: SelfLoopAnchor, loopRadius: number): SelfLoopPath {\n  const cx = Number.isFinite(anchor.centerX) ? anchor.centerX : 0;\n  const ay = Number.isFinite(anchor.topY) ? anchor.topY : 0;\n  const r = Number.isFinite(loopRadius) && loopRadius > 0 ? loopRadius : DEFAULT_LOOP_RADIUS;\n\n  const startX = cx + r;\n  const endX = cx - r;\n  const controlY = ay - r * CONTROL_REACH_Y;\n\n  return {\n    path: `M ${startX},${ay} C ${startX + r * CONTROL_REACH_X},${controlY} ${\n      endX - r * CONTROL_REACH_X\n    },${controlY} ${endX},${ay}`,\n    labelX: cx,\n    labelY: ay - r * APEX_FACTOR,\n  };\n}\n\n/**\n * The two handle anchors a self-loop actually joins, plus the box it has to clear.\n *\n * A self-loop's `sourceX/sourceY` and `targetX/targetY` are the SAME node's two handle\n * points, which is why they describe no useful straight line — but they are still the\n * only two points on the canvas the reader recognises as connectors, so the arc has to\n * start and end exactly on them. {@link selfLoopHandleArc} is the geometry that does\n * that; {@link selfLoopPath} remains the node-box arc used before a node is measured.\n */\nexport interface SelfLoopHandleAnchor {\n  /** Where the loop leaves the node — React Flow's own SOURCE handle anchor. */\n  sourceX: number;\n  sourceY: number;\n  /** Where it re-enters — React Flow's own TARGET handle anchor. */\n  targetX: number;\n  targetY: number;\n  /** The node's centre. Decides which way is \"out of the card\". */\n  centerX: number;\n  centerY: number;\n  /** The node's rendered size, so the arc clears the card instead of crossing it. */\n  width: number;\n  height: number;\n}\n\n/** Unit vector from the node's centre to a handle point, or `fallback` when degenerate. */\nfunction outward(\n  x: number,\n  y: number,\n  centerX: number,\n  centerY: number,\n  fallback: readonly [number, number],\n): readonly [number, number] {\n  const dx = x - centerX;\n  const dy = y - centerY;\n  const length = Math.hypot(dx, dy);\n  if (!Number.isFinite(length) || length < 1e-6) return fallback;\n  return [dx / length, dy / length];\n}\n\n/**\n * A cubic that leaves the SOURCE handle dot, bulges clear of the node on one side, and\n * re-enters at the TARGET handle dot.\n *\n * It is direction-agnostic by construction: the bulge is the source normal rotated a\n * quarter turn, so a top-to-bottom layout (handles on the bottom and top) gets a lasso\n * down the node's right-hand side, and a left-to-right layout (handles on the right and\n * left) gets an arc over the top — with no `direction` prop, and no list of cases to keep\n * in step with `layoutFlow`'s `HANDLE_BY_DIRECTION`.\n *\n * `loopRadius` is how far the curve shoots straight out of each dot before it turns, and\n * also the gap the arc's widest point keeps from the card's edge. The label sits at that\n * widest point — the cubic's `t = 0.5` midpoint — so it is off the node by construction.\n *\n * Never returns `NaN`: non-finite inputs fall back to `0`, a non-positive radius to\n * {@link DEFAULT_LOOP_RADIUS}, and a handle point sitting on the node's centre (nothing\n * measured yet) to a downward source normal.\n */\nexport function selfLoopHandleArc(anchor: SelfLoopHandleAnchor, loopRadius: number): SelfLoopPath {\n  const num = (value: number) => (Number.isFinite(value) ? value : 0);\n  const sx = num(anchor.sourceX);\n  const sy = num(anchor.sourceY);\n  const tx = num(anchor.targetX);\n  const ty = num(anchor.targetY);\n  const cx = num(anchor.centerX);\n  const cy = num(anchor.centerY);\n  const width = Math.max(0, num(anchor.width));\n  const height = Math.max(0, num(anchor.height));\n  const r = Number.isFinite(loopRadius) && loopRadius > 0 ? loopRadius : DEFAULT_LOOP_RADIUS;\n\n  const [osx, osy] = outward(sx, sy, cx, cy, [0, 1]);\n  const [otx, oty] = outward(tx, ty, cx, cy, [-osx, -osy]);\n  // A quarter turn from the source normal: the side the loop bulges out on.\n  const lx = osy;\n  const ly = -osx;\n  // How far the card extends along the bulge, plus the clearance we want beyond it.\n  const clearance = Math.abs(lx) * (width / 2) + Math.abs(ly) * (height / 2) + r;\n  // A cubic reaches only 3/4 of the way to its control points at the midpoint — its\n  // WIDEST point — so `clearance` has to be divided by that factor, not used directly.\n  // Used directly (the first cut of this function did) the apex lands at 0.75 × clearance,\n  // which for a 176 px card is 87 px against an 88 px half-width: the loop is drawn ON the\n  // card it is supposed to encircle, and its label — anchored at that same midpoint —\n  // prints on top of the activity's own name. Measured on the process map: one collision\n  // per direction that no amount of layout spacing could remove, because the arc's reach\n  // is a property of the node it belongs to, not of the gap to its neighbours.\n  const reach = (4 / 3) * clearance;\n\n  const c1x = sx + osx * r + lx * reach;\n  const c1y = sy + osy * r + ly * reach;\n  const c2x = tx + otx * r + lx * reach;\n  const c2y = ty + oty * r + ly * reach;\n\n  return {\n    path: `M ${sx},${sy} C ${c1x},${c1y} ${c2x},${c2y} ${tx},${ty}`,\n    // A cubic's midpoint is (P0 + 3·C1 + 3·C2 + P3) / 8 — the arc's apex, which `reach`\n    // above places `loopRadius` clear of the card, so the label sits off the node.\n    labelX: (sx + 3 * c1x + 3 * c2x + tx) / 8,\n    labelY: (sy + 3 * c1y + 3 * c2y + ty) / 8,\n  };\n}\n"],"mappings":";;;AASO,IAAM,sBAAsB;AAQnC,IAAM,kBAAkB;AACxB,IAAM,kBAAkB;AAExB,IAAM,cAAe,IAAI,IAAK;AA4BvB,SAAS,aAAa,QAAwB,YAAkC;AACrF,QAAM,KAAK,OAAO,SAAS,OAAO,OAAO,IAAI,OAAO,UAAU;AAC9D,QAAM,KAAK,OAAO,SAAS,OAAO,IAAI,IAAI,OAAO,OAAO;AACxD,QAAM,IAAI,OAAO,SAAS,UAAU,KAAK,aAAa,IAAI,aAAa;AAEvE,QAAM,SAAS,KAAK;AACpB,QAAM,OAAO,KAAK;AAClB,QAAM,WAAW,KAAK,IAAI;AAE1B,SAAO;AAAA,IACL,MAAM,KAAK,MAAM,IAAI,EAAE,MAAM,SAAS,IAAI,eAAe,IAAI,QAAQ,IACnE,OAAO,IAAI,eACb,IAAI,QAAQ,IAAI,IAAI,IAAI,EAAE;AAAA,IAC1B,QAAQ;AAAA,IACR,QAAQ,KAAK,IAAI;AAAA,EACnB;AACF;AA2BA,SAAS,QACP,GACA,GACA,SACA,SACA,UAC2B;AAC3B,QAAM,KAAK,IAAI;AACf,QAAM,KAAK,IAAI;AACf,QAAM,SAAS,KAAK,MAAM,IAAI,EAAE;AAChC,MAAI,CAAC,OAAO,SAAS,MAAM,KAAK,SAAS,KAAM,QAAO;AACtD,SAAO,CAAC,KAAK,QAAQ,KAAK,MAAM;AAClC;AAoBO,SAAS,kBAAkB,QAA8B,YAAkC;AAChG,QAAM,MAAM,CAAC,UAAmB,OAAO,SAAS,KAAK,IAAI,QAAQ;AACjE,QAAM,KAAK,IAAI,OAAO,OAAO;AAC7B,QAAM,KAAK,IAAI,OAAO,OAAO;AAC7B,QAAM,KAAK,IAAI,OAAO,OAAO;AAC7B,QAAM,KAAK,IAAI,OAAO,OAAO;AAC7B,QAAM,KAAK,IAAI,OAAO,OAAO;AAC7B,QAAM,KAAK,IAAI,OAAO,OAAO;AAC7B,QAAM,QAAQ,KAAK,IAAI,GAAG,IAAI,OAAO,KAAK,CAAC;AAC3C,QAAM,SAAS,KAAK,IAAI,GAAG,IAAI,OAAO,MAAM,CAAC;AAC7C,QAAM,IAAI,OAAO,SAAS,UAAU,KAAK,aAAa,IAAI,aAAa;AAEvE,QAAM,CAAC,KAAK,GAAG,IAAI,QAAQ,IAAI,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC;AACjD,QAAM,CAAC,KAAK,GAAG,IAAI,QAAQ,IAAI,IAAI,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC;AAEvD,QAAM,KAAK;AACX,QAAM,KAAK,CAAC;AAEZ,QAAM,YAAY,KAAK,IAAI,EAAE,KAAK,QAAQ,KAAK,KAAK,IAAI,EAAE,KAAK,SAAS,KAAK;AAS7E,QAAM,QAAS,IAAI,IAAK;AAExB,QAAM,MAAM,KAAK,MAAM,IAAI,KAAK;AAChC,QAAM,MAAM,KAAK,MAAM,IAAI,KAAK;AAChC,QAAM,MAAM,KAAK,MAAM,IAAI,KAAK;AAChC,QAAM,MAAM,KAAK,MAAM,IAAI,KAAK;AAEhC,SAAO;AAAA,IACL,MAAM,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,EAAE,IAAI,EAAE;AAAA;AAAA;AAAA,IAG7D,SAAS,KAAK,IAAI,MAAM,IAAI,MAAM,MAAM;AAAA,IACxC,SAAS,KAAK,IAAI,MAAM,IAAI,MAAM,MAAM;AAAA,EAC1C;AACF;","names":[]}

package/dist/chunk-TGWPM2CG.js

@@ -0,0 +1,199 @@
+"use client";
+
+// src/use-flow-groups/group-operations.ts
+import { getNodesBounds } from "@xyflow/react";
+var FLOW_GROUP_NODE_TYPE = "group";
+var DEFAULT_GROUP_PADDING = 28;
+var GROUP_HEADER_OFFSET = 44;
+var OVERVIEW_WIDTH = 220;
+var OVERVIEW_HEIGHT = 48;
+var COLLAPSED_STATE_KEY = "__flowGroupCollapsedState";
+function isFlowGroupProxyEdge(edge) {
+  return Boolean(edge.data?.__flowGroupProxy);
+}
+function proxyEdgeId(groupId, originalEdgeId) {
+  return `flow-group-proxy__${groupId}__${originalEdgeId}`;
+}
+function readCollapsedState(node) {
+  return node.data?.[COLLAPSED_STATE_KEY];
+}
+function collectDescendantIds(nodes, groupId) {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    if (n.parentId) {
+      const arr = childrenByParent.get(n.parentId);
+      if (arr) arr.push(n);
+      else childrenByParent.set(n.parentId, [n]);
+    }
+  }
+  const out = /* @__PURE__ */ new Set();
+  const stack = [...childrenByParent.get(groupId) ?? []];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    if (out.has(n.id)) continue;
+    out.add(n.id);
+    const kids = childrenByParent.get(n.id);
+    if (kids) stack.push(...kids);
+  }
+  return out;
+}
+function groupNodes(nodes, edges, nodeIds, options) {
+  const idSet = new Set(nodeIds);
+  const children = nodes.filter((n) => idSet.has(n.id));
+  if (children.length === 0) return { nodes, edges };
+  const bounds = getNodesBounds(children);
+  const padding = options.padding ?? DEFAULT_GROUP_PADDING;
+  const originX = bounds.x - padding;
+  const originY = bounds.y - padding - GROUP_HEADER_OFFSET;
+  const data = {
+    title: options.title ?? "Group",
+    childCount: children.length,
+    ...options.tone ? { tone: options.tone } : {}
+  };
+  const groupNode = {
+    id: options.groupId,
+    type: FLOW_GROUP_NODE_TYPE,
+    position: { x: originX, y: originY },
+    width: bounds.width + padding * 2,
+    height: bounds.height + padding * 2 + GROUP_HEADER_OFFSET,
+    data
+  };
+  const reparented = /* @__PURE__ */ new Map();
+  for (const child of children) {
+    reparented.set(child.id, {
+      ...child,
+      parentId: options.groupId,
+      extent: "parent",
+      position: { x: child.position.x - originX, y: child.position.y - originY }
+    });
+  }
+  let earliest = nodes.length;
+  for (let i = 0; i < nodes.length; i++) {
+    if (idSet.has(nodes[i].id)) {
+      earliest = i;
+      break;
+    }
+  }
+  const mapped = nodes.map((n) => reparented.get(n.id) ?? n);
+  const resultNodes = [...mapped.slice(0, earliest), groupNode, ...mapped.slice(earliest)];
+  return { nodes: resultNodes, edges };
+}
+function ungroup(nodes, edges, groupId) {
+  const group = nodes.find((n) => n.id === groupId);
+  if (!group) return { nodes, edges };
+  const base = group.data?.collapsed ? expandGroup(nodes, edges, groupId) : { nodes, edges };
+  const liveGroup = base.nodes.find((n) => n.id === groupId);
+  const gx = liveGroup.position.x;
+  const gy = liveGroup.position.y;
+  const resultNodes = base.nodes.filter((n) => n.id !== groupId).map((n) => {
+    if (n.parentId === groupId) {
+      const {
+        parentId: _parentId,
+        extent: _extent,
+        ...rest
+      } = n;
+      return {
+        ...rest,
+        position: { x: n.position.x + gx, y: n.position.y + gy }
+      };
+    }
+    return n;
+  });
+  return { nodes: resultNodes, edges: base.edges };
+}
+function collapseGroup(nodes, edges, groupId) {
+  const group = nodes.find((n) => n.id === groupId);
+  if (!group) return { nodes, edges };
+  if (group.data?.collapsed) return { nodes, edges };
+  const descendantIds = collectDescendantIds(nodes, groupId);
+  const descendantSnapshots = nodes.filter((n) => descendantIds.has(n.id));
+  const directChildCount = nodes.filter((n) => n.parentId === groupId).length;
+  const isInside = (id) => descendantIds.has(id);
+  const reroutedEdges = [];
+  const proxyEdges = [];
+  for (const edge of edges) {
+    const sourceInside = isInside(edge.source);
+    const targetInside = isInside(edge.target);
+    if (sourceInside === targetInside) continue;
+    reroutedEdges.push(edge);
+    const proxyData = {
+      ...edge.data ?? {},
+      __flowGroupProxy: true,
+      groupId
+    };
+    proxyEdges.push({
+      ...edge,
+      id: proxyEdgeId(groupId, edge.id),
+      source: sourceInside ? groupId : edge.source,
+      target: targetInside ? groupId : edge.target,
+      sourceHandle: void 0,
+      targetHandle: void 0,
+      data: proxyData
+    });
+  }
+  const collapsedState = {
+    groupSnapshot: group,
+    descendantSnapshots,
+    reroutedEdges
+  };
+  const resultNodes = nodes.map((n) => {
+    if (n.id === groupId) {
+      return {
+        ...n,
+        width: OVERVIEW_WIDTH,
+        height: OVERVIEW_HEIGHT,
+        data: {
+          ...n.data,
+          collapsed: true,
+          childCount: directChildCount,
+          [COLLAPSED_STATE_KEY]: collapsedState
+        }
+      };
+    }
+    if (descendantIds.has(n.id)) {
+      return { ...n, hidden: true };
+    }
+    return n;
+  });
+  const reroutedIds = new Set(reroutedEdges.map((e) => e.id));
+  const resultEdges = edges.map(
+    (e) => reroutedIds.has(e.id) ? { ...e, hidden: true } : e
+  );
+  resultEdges.push(...proxyEdges);
+  return { nodes: resultNodes, edges: resultEdges };
+}
+function expandGroup(nodes, edges, groupId) {
+  const group = nodes.find((n) => n.id === groupId);
+  const state = group ? readCollapsedState(group) : void 0;
+  if (!group || !state) return { nodes, edges };
+  const snapshotById = new Map(state.descendantSnapshots.map((n) => [n.id, n]));
+  const reroutedById = new Map(state.reroutedEdges.map((e) => [e.id, e]));
+  const resultNodes = nodes.map((n) => {
+    if (n.id === groupId) return state.groupSnapshot;
+    const snap = snapshotById.get(n.id);
+    return snap ? snap : n;
+  });
+  const resultEdges = edges.filter(
+    (e) => !(isFlowGroupProxyEdge(e) && e.data?.groupId === groupId)
+  ).map((e) => {
+    const original = reroutedById.get(e.id);
+    return original ? original : e;
+  });
+  return { nodes: resultNodes, edges: resultEdges };
+}
+function toggleGroupCollapsed(nodes, edges, groupId) {
+  const group = nodes.find((n) => n.id === groupId);
+  if (!group) return { nodes, edges };
+  return group.data?.collapsed ? expandGroup(nodes, edges, groupId) : collapseGroup(nodes, edges, groupId);
+}
+
+export {
+  FLOW_GROUP_NODE_TYPE,
+  isFlowGroupProxyEdge,
+  groupNodes,
+  ungroup,
+  collapseGroup,
+  expandGroup,
+  toggleGroupCollapsed
+};
+//# sourceMappingURL=chunk-TGWPM2CG.js.map

package/dist/chunk-TGWPM2CG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/use-flow-groups/group-operations.ts"],"sourcesContent":["import { getNodesBounds, type Edge, type Node } from \"@xyflow/react\";\nimport type { FlowGroupNodeData, FlowGroupTone } from \"../flow-group-node\";\n\n/**\n * Pure, framework-agnostic grouping operations over `nodes`/`edges` arrays.\n *\n * Every function is a **pure transform** — it never mutates its inputs and\n * returns a fresh `{ nodes, edges }`. This is the testable core; `useFlowGroups`\n * is a thin hook that wires these to a live canvas via `useReactFlow()`.\n */\n\n/** Node type used for the group container (matches `nodeTypes={{ group: FlowGroupNode }}`). */\nexport const FLOW_GROUP_NODE_TYPE = \"group\";\n\n/** Padding (px) left around the child bounds when a group is created. */\nconst DEFAULT_GROUP_PADDING = 28;\n/** Extra top space reserved for the group header so children don't sit under it. */\nconst GROUP_HEADER_OFFSET = 44;\n/** Fixed size of the collapsed \"overview chip\". */\nconst OVERVIEW_WIDTH = 220;\nconst OVERVIEW_HEIGHT = 48;\n\nexport interface GroupNodesOptions {\n  /** Id for the new group node. Required so the operation stays deterministic/testable. */\n  groupId: string;\n  /** Header title for the group. @default \"Group\" */\n  title?: string;\n  /** Accent tone for the group header. */\n  tone?: FlowGroupTone;\n  /** Padding (px) around the child bounds. @default 28 */\n  padding?: number;\n}\n\nexport interface FlowGroupOperationResult<\n  NodeType extends Node = Node,\n  EdgeType extends Edge = Edge,\n> {\n  nodes: NodeType[];\n  edges: EdgeType[];\n}\n\n/**\n * Snapshot stashed on a collapsed group's `data` so `expandGroup` can restore the\n * exact pre-collapse graph (an exact inverse). Holds original node/edge object\n * references — never mutated — so restoration is object-exact.\n */\ninterface FlowGroupCollapsedState {\n  /** The group node exactly as it was before collapse (no collapsed state on it). */\n  groupSnapshot: Node;\n  /** Every descendant node exactly as it was before collapse. */\n  descendantSnapshots: Node[];\n  /** The boundary-crossing edges exactly as they were before rerouting. */\n  reroutedEdges: Edge[];\n}\n\nconst COLLAPSED_STATE_KEY = \"__flowGroupCollapsedState\";\n\n/** Marker + metadata written onto a proxy edge's `data`. */\nexport interface FlowGroupProxyEdgeData extends Record<string, unknown> {\n  __flowGroupProxy: true;\n  /** Id of the collapsed group this proxy edge stands in for. */\n  groupId: string;\n}\n\n/** True if `edge` is a proxy edge synthesized for a collapsed group. */\nexport function isFlowGroupProxyEdge(edge: Edge): boolean {\n  return Boolean((edge.data as Partial<FlowGroupProxyEdgeData> | undefined)?.__flowGroupProxy);\n}\n\nfunction proxyEdgeId(groupId: string, originalEdgeId: string): string {\n  return `flow-group-proxy__${groupId}__${originalEdgeId}`;\n}\n\nfunction readCollapsedState(node: Node): FlowGroupCollapsedState | undefined {\n  return (node.data as Record<string, unknown> | undefined)?.[COLLAPSED_STATE_KEY] as\n    | FlowGroupCollapsedState\n    | undefined;\n}\n\n/** All node ids whose parent chain reaches `groupId` (children, grandchildren, …). */\nfunction collectDescendantIds(nodes: Node[], groupId: string): Set<string> {\n  const childrenByParent = new Map<string, Node[]>();\n  for (const n of nodes) {\n    if (n.parentId) {\n      const arr = childrenByParent.get(n.parentId);\n      if (arr) arr.push(n);\n      else childrenByParent.set(n.parentId, [n]);\n    }\n  }\n\n  const out = new Set<string>();\n  const stack = [...(childrenByParent.get(groupId) ?? [])];\n  while (stack.length > 0) {\n    const n = stack.pop()!;\n    if (out.has(n.id)) continue;\n    out.add(n.id);\n    const kids = childrenByParent.get(n.id);\n    if (kids) stack.push(...kids);\n  }\n  return out;\n}\n\n/**\n * Wrap `nodeIds` (assumed top-level) in a new `FlowGroupNode` parent.\n *\n * - Computes the child bounds with `getNodesBounds`.\n * - Inserts the group node **before** its children in the array (React Flow\n *   requires a parent to precede its children).\n * - Re-parents each child (`parentId`, `extent: \"parent\"`) and rewrites its\n *   position to be **relative to the group origin**.\n */\nexport function groupNodes<NodeType extends Node = Node, EdgeType extends Edge = Edge>(\n  nodes: NodeType[],\n  edges: EdgeType[],\n  nodeIds: string[],\n  options: GroupNodesOptions,\n): FlowGroupOperationResult<NodeType, EdgeType> {\n  const idSet = new Set(nodeIds);\n  const children = nodes.filter((n) => idSet.has(n.id));\n  if (children.length === 0) return { nodes, edges };\n\n  const bounds = getNodesBounds(children);\n  const padding = options.padding ?? DEFAULT_GROUP_PADDING;\n  const originX = bounds.x - padding;\n  const originY = bounds.y - padding - GROUP_HEADER_OFFSET;\n\n  const data: FlowGroupNodeData = {\n    title: options.title ?? \"Group\",\n    childCount: children.length,\n    ...(options.tone ? { tone: options.tone } : {}),\n  };\n\n  const groupNode = {\n    id: options.groupId,\n    type: FLOW_GROUP_NODE_TYPE,\n    position: { x: originX, y: originY },\n    width: bounds.width + padding * 2,\n    height: bounds.height + padding * 2 + GROUP_HEADER_OFFSET,\n    data,\n  } as unknown as NodeType;\n\n  const reparented = new Map<string, NodeType>();\n  for (const child of children) {\n    reparented.set(child.id, {\n      ...child,\n      parentId: options.groupId,\n      extent: \"parent\",\n      position: { x: child.position.x - originX, y: child.position.y - originY },\n    } as NodeType);\n  }\n\n  let earliest = nodes.length;\n  for (let i = 0; i < nodes.length; i++) {\n    if (idSet.has(nodes[i]!.id)) {\n      earliest = i;\n      break;\n    }\n  }\n\n  const mapped = nodes.map((n) => reparented.get(n.id) ?? n);\n  const resultNodes = [...mapped.slice(0, earliest), groupNode, ...mapped.slice(earliest)];\n  return { nodes: resultNodes, edges };\n}\n\n/**\n * Dissolve a group: remove the group node and restore its **direct** children to\n * absolute positions (dropping `parentId`/`extent`). If the group is currently\n * collapsed it is expanded first, so ungrouping a collapsed group is safe.\n */\nexport function ungroup<NodeType extends Node = Node, EdgeType extends Edge = Edge>(\n  nodes: NodeType[],\n  edges: EdgeType[],\n  groupId: string,\n): FlowGroupOperationResult<NodeType, EdgeType> {\n  const group = nodes.find((n) => n.id === groupId);\n  if (!group) return { nodes, edges };\n\n  const base = (group.data as FlowGroupNodeData | undefined)?.collapsed\n    ? expandGroup(nodes, edges, groupId)\n    : { nodes, edges };\n\n  const liveGroup = base.nodes.find((n) => n.id === groupId)!;\n  const gx = liveGroup.position.x;\n  const gy = liveGroup.position.y;\n\n  const resultNodes = base.nodes\n    .filter((n) => n.id !== groupId)\n    .map((n) => {\n      if (n.parentId === groupId) {\n        const {\n          parentId: _parentId,\n          extent: _extent,\n          ...rest\n        } = n as NodeType & {\n          parentId?: string;\n          extent?: unknown;\n        };\n        return {\n          ...rest,\n          position: { x: n.position.x + gx, y: n.position.y + gy },\n        } as NodeType;\n      }\n      return n;\n    });\n\n  return { nodes: resultNodes, edges: base.edges };\n}\n\n/**\n * Collapse a group to an overview chip.\n *\n * - Hides every descendant (including nested groups and their subtrees).\n * - Shrinks the group to a fixed overview size and marks `data.collapsed`.\n * - Re-routes every edge that **crosses the collapse boundary** (exactly one\n *   endpoint inside the collapsed subtree) to a **proxy edge** targeting the\n *   group node; the original edge is hidden and stashed for restoration.\n * - Edges fully inside or fully outside the subtree are left untouched.\n *\n * The full pre-collapse graph is stashed on the group's `data` so `expandGroup`\n * is an exact inverse. Nested collapse is handled by snapshotting each\n * descendant's exact prior state (a subgroup that was already collapsed stays\n * collapsed on expand — no double-unhide).\n */\nexport function collapseGroup<NodeType extends Node = Node, EdgeType extends Edge = Edge>(\n  nodes: NodeType[],\n  edges: EdgeType[],\n  groupId: string,\n): FlowGroupOperationResult<NodeType, EdgeType> {\n  const group = nodes.find((n) => n.id === groupId);\n  if (!group) return { nodes, edges };\n  if ((group.data as FlowGroupNodeData | undefined)?.collapsed) return { nodes, edges };\n\n  const descendantIds = collectDescendantIds(nodes, groupId);\n\n  const descendantSnapshots = nodes.filter((n) => descendantIds.has(n.id));\n  const directChildCount = nodes.filter((n) => n.parentId === groupId).length;\n\n  const isInside = (id: string) => descendantIds.has(id);\n  const reroutedEdges: EdgeType[] = [];\n  const proxyEdges: EdgeType[] = [];\n  for (const edge of edges) {\n    const sourceInside = isInside(edge.source);\n    const targetInside = isInside(edge.target);\n    if (sourceInside === targetInside) continue; // fully inside or fully outside\n\n    reroutedEdges.push(edge);\n    const proxyData: FlowGroupProxyEdgeData = {\n      ...(edge.data ?? {}),\n      __flowGroupProxy: true,\n      groupId,\n    };\n    proxyEdges.push({\n      ...edge,\n      id: proxyEdgeId(groupId, edge.id),\n      source: sourceInside ? groupId : edge.source,\n      target: targetInside ? groupId : edge.target,\n      sourceHandle: undefined,\n      targetHandle: undefined,\n      data: proxyData,\n    } as EdgeType);\n  }\n\n  const collapsedState: FlowGroupCollapsedState = {\n    groupSnapshot: group,\n    descendantSnapshots,\n    reroutedEdges,\n  };\n\n  const resultNodes = nodes.map((n) => {\n    if (n.id === groupId) {\n      return {\n        ...n,\n        width: OVERVIEW_WIDTH,\n        height: OVERVIEW_HEIGHT,\n        data: {\n          ...(n.data as Record<string, unknown>),\n          collapsed: true,\n          childCount: directChildCount,\n          [COLLAPSED_STATE_KEY]: collapsedState,\n        },\n      } as NodeType;\n    }\n    if (descendantIds.has(n.id)) {\n      return { ...n, hidden: true } as NodeType;\n    }\n    return n;\n  });\n\n  const reroutedIds = new Set(reroutedEdges.map((e) => e.id));\n  const resultEdges = edges.map((e) =>\n    reroutedIds.has(e.id) ? ({ ...e, hidden: true } as EdgeType) : e,\n  );\n  resultEdges.push(...proxyEdges);\n\n  return { nodes: resultNodes, edges: resultEdges };\n}\n\n/**\n * Expand a collapsed group — the exact inverse of `collapseGroup`. Restores the\n * group node, un-hides the descendant subtree (to each node's exact prior\n * state), removes this group's proxy edges and restores the original edges.\n * No-op if the group isn't collapsed.\n */\nexport function expandGroup<NodeType extends Node = Node, EdgeType extends Edge = Edge>(\n  nodes: NodeType[],\n  edges: EdgeType[],\n  groupId: string,\n): FlowGroupOperationResult<NodeType, EdgeType> {\n  const group = nodes.find((n) => n.id === groupId);\n  const state = group ? readCollapsedState(group) : undefined;\n  if (!group || !state) return { nodes, edges };\n\n  const snapshotById = new Map(state.descendantSnapshots.map((n) => [n.id, n]));\n  const reroutedById = new Map(state.reroutedEdges.map((e) => [e.id, e]));\n\n  const resultNodes = nodes.map((n) => {\n    if (n.id === groupId) return state.groupSnapshot as NodeType;\n    const snap = snapshotById.get(n.id);\n    return snap ? (snap as NodeType) : n;\n  });\n\n  const resultEdges = edges\n    .filter(\n      (e) =>\n        !(\n          isFlowGroupProxyEdge(e) &&\n          (e.data as Partial<FlowGroupProxyEdgeData> | undefined)?.groupId === groupId\n        ),\n    )\n    .map((e) => {\n      const original = reroutedById.get(e.id);\n      return original ? (original as EdgeType) : e;\n    });\n\n  return { nodes: resultNodes, edges: resultEdges };\n}\n\n/** Collapse if expanded, expand if collapsed. */\nexport function toggleGroupCollapsed<NodeType extends Node = Node, EdgeType extends Edge = Edge>(\n  nodes: NodeType[],\n  edges: EdgeType[],\n  groupId: string,\n): FlowGroupOperationResult<NodeType, EdgeType> {\n  const group = nodes.find((n) => n.id === groupId);\n  if (!group) return { nodes, edges };\n  return (group.data as FlowGroupNodeData | undefined)?.collapsed\n    ? expandGroup(nodes, edges, groupId)\n    : collapseGroup(nodes, edges, groupId);\n}\n"],"mappings":";;;AAAA,SAAS,sBAA4C;AAY9C,IAAM,uBAAuB;AAGpC,IAAM,wBAAwB;AAE9B,IAAM,sBAAsB;AAE5B,IAAM,iBAAiB;AACvB,IAAM,kBAAkB;AAmCxB,IAAM,sBAAsB;AAUrB,SAAS,qBAAqB,MAAqB;AACxD,SAAO,QAAS,KAAK,MAAsD,gBAAgB;AAC7F;AAEA,SAAS,YAAY,SAAiB,gBAAgC;AACpE,SAAO,qBAAqB,OAAO,KAAK,cAAc;AACxD;AAEA,SAAS,mBAAmB,MAAiD;AAC3E,SAAQ,KAAK,OAA+C,mBAAmB;AAGjF;AAGA,SAAS,qBAAqB,OAAe,SAA8B;AACzE,QAAM,mBAAmB,oBAAI,IAAoB;AACjD,aAAW,KAAK,OAAO;AACrB,QAAI,EAAE,UAAU;AACd,YAAM,MAAM,iBAAiB,IAAI,EAAE,QAAQ;AAC3C,UAAI,IAAK,KAAI,KAAK,CAAC;AAAA,UACd,kBAAiB,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;AAAA,IAC3C;AAAA,EACF;AAEA,QAAM,MAAM,oBAAI,IAAY;AAC5B,QAAM,QAAQ,CAAC,GAAI,iBAAiB,IAAI,OAAO,KAAK,CAAC,CAAE;AACvD,SAAO,MAAM,SAAS,GAAG;AACvB,UAAM,IAAI,MAAM,IAAI;AACpB,QAAI,IAAI,IAAI,EAAE,EAAE,EAAG;AACnB,QAAI,IAAI,EAAE,EAAE;AACZ,UAAM,OAAO,iBAAiB,IAAI,EAAE,EAAE;AACtC,QAAI,KAAM,OAAM,KAAK,GAAG,IAAI;AAAA,EAC9B;AACA,SAAO;AACT;AAWO,SAAS,WACd,OACA,OACA,SACA,SAC8C;AAC9C,QAAM,QAAQ,IAAI,IAAI,OAAO;AAC7B,QAAM,WAAW,MAAM,OAAO,CAAC,MAAM,MAAM,IAAI,EAAE,EAAE,CAAC;AACpD,MAAI,SAAS,WAAW,EAAG,QAAO,EAAE,OAAO,MAAM;AAEjD,QAAM,SAAS,eAAe,QAAQ;AACtC,QAAM,UAAU,QAAQ,WAAW;AACnC,QAAM,UAAU,OAAO,IAAI;AAC3B,QAAM,UAAU,OAAO,IAAI,UAAU;AAErC,QAAM,OAA0B;AAAA,IAC9B,OAAO,QAAQ,SAAS;AAAA,IACxB,YAAY,SAAS;AAAA,IACrB,GAAI,QAAQ,OAAO,EAAE,MAAM,QAAQ,KAAK,IAAI,CAAC;AAAA,EAC/C;AAEA,QAAM,YAAY;AAAA,IAChB,IAAI,QAAQ;AAAA,IACZ,MAAM;AAAA,IACN,UAAU,EAAE,GAAG,SAAS,GAAG,QAAQ;AAAA,IACnC,OAAO,OAAO,QAAQ,UAAU;AAAA,IAChC,QAAQ,OAAO,SAAS,UAAU,IAAI;AAAA,IACtC;AAAA,EACF;AAEA,QAAM,aAAa,oBAAI,IAAsB;AAC7C,aAAW,SAAS,UAAU;AAC5B,eAAW,IAAI,MAAM,IAAI;AAAA,MACvB,GAAG;AAAA,MACH,UAAU,QAAQ;AAAA,MAClB,QAAQ;AAAA,MACR,UAAU,EAAE,GAAG,MAAM,SAAS,IAAI,SAAS,GAAG,MAAM,SAAS,IAAI,QAAQ;AAAA,IAC3E,CAAa;AAAA,EACf;AAEA,MAAI,WAAW,MAAM;AACrB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,QAAI,MAAM,IAAI,MAAM,CAAC,EAAG,EAAE,GAAG;AAC3B,iBAAW;AACX;AAAA,IACF;AAAA,EACF;AAEA,QAAM,SAAS,MAAM,IAAI,CAAC,MAAM,WAAW,IAAI,EAAE,EAAE,KAAK,CAAC;AACzD,QAAM,cAAc,CAAC,GAAG,OAAO,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,OAAO,MAAM,QAAQ,CAAC;AACvF,SAAO,EAAE,OAAO,aAAa,MAAM;AACrC;AAOO,SAAS,QACd,OACA,OACA,SAC8C;AAC9C,QAAM,QAAQ,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,OAAO;AAChD,MAAI,CAAC,MAAO,QAAO,EAAE,OAAO,MAAM;AAElC,QAAM,OAAQ,MAAM,MAAwC,YACxD,YAAY,OAAO,OAAO,OAAO,IACjC,EAAE,OAAO,MAAM;AAEnB,QAAM,YAAY,KAAK,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,OAAO;AACzD,QAAM,KAAK,UAAU,SAAS;AAC9B,QAAM,KAAK,UAAU,SAAS;AAE9B,QAAM,cAAc,KAAK,MACtB,OAAO,CAAC,MAAM,EAAE,OAAO,OAAO,EAC9B,IAAI,CAAC,MAAM;AACV,QAAI,EAAE,aAAa,SAAS;AAC1B,YAAM;AAAA,QACJ,UAAU;AAAA,QACV,QAAQ;AAAA,QACR,GAAG;AAAA,MACL,IAAI;AAIJ,aAAO;AAAA,QACL,GAAG;AAAA,QACH,UAAU,EAAE,GAAG,EAAE,SAAS,IAAI,IAAI,GAAG,EAAE,SAAS,IAAI,GAAG;AAAA,MACzD;AAAA,IACF;AACA,WAAO;AAAA,EACT,CAAC;AAEH,SAAO,EAAE,OAAO,aAAa,OAAO,KAAK,MAAM;AACjD;AAiBO,SAAS,cACd,OACA,OACA,SAC8C;AAC9C,QAAM,QAAQ,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,OAAO;AAChD,MAAI,CAAC,MAAO,QAAO,EAAE,OAAO,MAAM;AAClC,MAAK,MAAM,MAAwC,UAAW,QAAO,EAAE,OAAO,MAAM;AAEpF,QAAM,gBAAgB,qBAAqB,OAAO,OAAO;AAEzD,QAAM,sBAAsB,MAAM,OAAO,CAAC,MAAM,cAAc,IAAI,EAAE,EAAE,CAAC;AACvE,QAAM,mBAAmB,MAAM,OAAO,CAAC,MAAM,EAAE,aAAa,OAAO,EAAE;AAErE,QAAM,WAAW,CAAC,OAAe,cAAc,IAAI,EAAE;AACrD,QAAM,gBAA4B,CAAC;AACnC,QAAM,aAAyB,CAAC;AAChC,aAAW,QAAQ,OAAO;AACxB,UAAM,eAAe,SAAS,KAAK,MAAM;AACzC,UAAM,eAAe,SAAS,KAAK,MAAM;AACzC,QAAI,iBAAiB,aAAc;AAEnC,kBAAc,KAAK,IAAI;AACvB,UAAM,YAAoC;AAAA,MACxC,GAAI,KAAK,QAAQ,CAAC;AAAA,MAClB,kBAAkB;AAAA,MAClB;AAAA,IACF;AACA,eAAW,KAAK;AAAA,MACd,GAAG;AAAA,MACH,IAAI,YAAY,SAAS,KAAK,EAAE;AAAA,MAChC,QAAQ,eAAe,UAAU,KAAK;AAAA,MACtC,QAAQ,eAAe,UAAU,KAAK;AAAA,MACtC,cAAc;AAAA,MACd,cAAc;AAAA,MACd,MAAM;AAAA,IACR,CAAa;AAAA,EACf;AAEA,QAAM,iBAA0C;AAAA,IAC9C,eAAe;AAAA,IACf;AAAA,IACA;AAAA,EACF;AAEA,QAAM,cAAc,MAAM,IAAI,CAAC,MAAM;AACnC,QAAI,EAAE,OAAO,SAAS;AACpB,aAAO;AAAA,QACL,GAAG;AAAA,QACH,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,MAAM;AAAA,UACJ,GAAI,EAAE;AAAA,UACN,WAAW;AAAA,UACX,YAAY;AAAA,UACZ,CAAC,mBAAmB,GAAG;AAAA,QACzB;AAAA,MACF;AAAA,IACF;AACA,QAAI,cAAc,IAAI,EAAE,EAAE,GAAG;AAC3B,aAAO,EAAE,GAAG,GAAG,QAAQ,KAAK;AAAA,IAC9B;AACA,WAAO;AAAA,EACT,CAAC;AAED,QAAM,cAAc,IAAI,IAAI,cAAc,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AAC1D,QAAM,cAAc,MAAM;AAAA,IAAI,CAAC,MAC7B,YAAY,IAAI,EAAE,EAAE,IAAK,EAAE,GAAG,GAAG,QAAQ,KAAK,IAAiB;AAAA,EACjE;AACA,cAAY,KAAK,GAAG,UAAU;AAE9B,SAAO,EAAE,OAAO,aAAa,OAAO,YAAY;AAClD;AAQO,SAAS,YACd,OACA,OACA,SAC8C;AAC9C,QAAM,QAAQ,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,OAAO;AAChD,QAAM,QAAQ,QAAQ,mBAAmB,KAAK,IAAI;AAClD,MAAI,CAAC,SAAS,CAAC,MAAO,QAAO,EAAE,OAAO,MAAM;AAE5C,QAAM,eAAe,IAAI,IAAI,MAAM,oBAAoB,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AAC5E,QAAM,eAAe,IAAI,IAAI,MAAM,cAAc,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AAEtE,QAAM,cAAc,MAAM,IAAI,CAAC,MAAM;AACnC,QAAI,EAAE,OAAO,QAAS,QAAO,MAAM;AACnC,UAAM,OAAO,aAAa,IAAI,EAAE,EAAE;AAClC,WAAO,OAAQ,OAAoB;AAAA,EACrC,CAAC;AAED,QAAM,cAAc,MACjB;AAAA,IACC,CAAC,MACC,EACE,qBAAqB,CAAC,KACrB,EAAE,MAAsD,YAAY;AAAA,EAE3E,EACC,IAAI,CAAC,MAAM;AACV,UAAM,WAAW,aAAa,IAAI,EAAE,EAAE;AACtC,WAAO,WAAY,WAAwB;AAAA,EAC7C,CAAC;AAEH,SAAO,EAAE,OAAO,aAAa,OAAO,YAAY;AAClD;AAGO,SAAS,qBACd,OACA,OACA,SAC8C;AAC9C,QAAM,QAAQ,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,OAAO;AAChD,MAAI,CAAC,MAAO,QAAO,EAAE,OAAO,MAAM;AAClC,SAAQ,MAAM,MAAwC,YAClD,YAAY,OAAO,OAAO,OAAO,IACjC,cAAc,OAAO,OAAO,OAAO;AACzC;","names":[]}

package/dist/chunk-TSB6RE7L.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-TSB6RE7L.js.map

package/dist/chunk-TSB6RE7L.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-UPV2MT4O.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-UPV2MT4O.js.map

package/dist/chunk-UPV2MT4O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-UZJZY4A5.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-UZJZY4A5.js.map

package/dist/chunk-UZJZY4A5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-W3TQMUGX.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-W3TQMUGX.js.map

package/dist/chunk-W3TQMUGX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-WN46RIOC.js

@@ -0,0 +1,29 @@
+"use client";
+
+// src/flow-mini-map/flow-mini-map.tsx
+import { MiniMap } from "@xyflow/react";
+import { cn } from "@elabs-ai/components-ui/lib/cn";
+import { jsx } from "react/jsx-runtime";
+function FlowMiniMap({
+  className,
+  nodeColor = "var(--flow-minimap-node)",
+  nodeStrokeColor = "var(--flow-minimap-node)",
+  maskColor = "var(--flow-minimap-mask)",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    MiniMap,
+    {
+      className: cn("!rounded-lg !bg-surface-elevated !shadow-ring-sm", className),
+      nodeColor,
+      nodeStrokeColor,
+      maskColor,
+      ...props
+    }
+  );
+}
+
+export {
+  FlowMiniMap
+};
+//# sourceMappingURL=chunk-WN46RIOC.js.map

package/dist/chunk-WN46RIOC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/flow-mini-map/flow-mini-map.tsx"],"sourcesContent":["import { MiniMap, type MiniMapProps, type Node } from \"@xyflow/react\";\nimport { cn } from \"@elabs-ai/components-ui/lib/cn\";\n\nexport type FlowMiniMapProps<NodeType extends Node = Node> = MiniMapProps<NodeType>;\n\n/**\n * Branded preset over React Flow's `<MiniMap>` — sources node/mask colors from\n * the `--flow-minimap-*` tokens so the overview stays theme-aware (the raw\n * `MiniMap` re-export defaults to library colors and renders theme-blind,\n * especially under a low-chroma theme). Every prop can still be overridden; render\n * inside a `<CanvasShell>` (it needs the React Flow context via `useStore`).\n */\nexport function FlowMiniMap<NodeType extends Node = Node>({\n  className,\n  nodeColor = \"var(--flow-minimap-node)\",\n  nodeStrokeColor = \"var(--flow-minimap-node)\",\n  maskColor = \"var(--flow-minimap-mask)\",\n  ...props\n}: FlowMiniMapProps<NodeType>) {\n  return (\n    <MiniMap\n      className={cn(\"!rounded-lg !bg-surface-elevated !shadow-ring-sm\", className)}\n      nodeColor={nodeColor}\n      nodeStrokeColor={nodeStrokeColor}\n      maskColor={maskColor}\n      {...props}\n    />\n  );\n}\n"],"mappings":";;;AAAA,SAAS,eAA6C;AACtD,SAAS,UAAU;AAmBf;AARG,SAAS,YAA0C;AAAA,EACxD;AAAA,EACA,YAAY;AAAA,EACZ,kBAAkB;AAAA,EAClB,YAAY;AAAA,EACZ,GAAG;AACL,GAA+B;AAC7B,SACE;AAAA,IAAC;AAAA;AAAA,MACC,WAAW,GAAG,oDAAoD,SAAS;AAAA,MAC3E;AAAA,MACA;AAAA,MACA;AAAA,MACC,GAAG;AAAA;AAAA,EACN;AAEJ;","names":[]}

package/dist/chunk-XZFE2YYH.js

@@ -0,0 +1,70 @@
+"use client";
+import {
+  FlowEdgePath
+} from "./chunk-SXXJV6YJ.js";
+
+// src/flow-button-edge/flow-button-edge.tsx
+import { EdgeLabelRenderer, getBezierPath } from "@xyflow/react";
+import { Plus } from "lucide-react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function FlowButtonEdge({
+  id,
+  sourceX,
+  sourceY,
+  targetX,
+  targetY,
+  sourcePosition,
+  targetPosition,
+  markerEnd,
+  style,
+  data
+}) {
+  const [edgePath, labelX, labelY] = getBezierPath({
+    sourceX,
+    sourceY,
+    sourcePosition,
+    targetX,
+    targetY,
+    targetPosition
+  });
+  const label = data?.label ?? "Insert node on edge";
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      FlowEdgePath,
+      {
+        id,
+        path: edgePath,
+        markerEnd,
+        "data-slot": "flow-button-edge",
+        stroke: "var(--flow-edge)",
+        strokeWidth: 1.5,
+        style
+      }
+    ),
+    /* @__PURE__ */ jsx(EdgeLabelRenderer, { children: /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          transform: `translate(-50%, -50%) translate(${labelX}px, ${labelY}px)`
+        },
+        className: "nodrag nopan pointer-events-auto",
+        children: /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": label,
+            onClick: () => data?.onInsert?.(),
+            className: "flex size-5 items-center justify-center rounded-full border border-flow-group-border bg-flow-node text-flow-node-foreground shadow-sm transition-colors duration-fast ease-standard hover:bg-accent hover:text-accent-foreground focus-ring",
+            children: /* @__PURE__ */ jsx(Plus, { className: "size-3", "aria-hidden": "true" })
+          }
+        )
+      }
+    ) })
+  ] });
+}
+
+export {
+  FlowButtonEdge
+};
+//# sourceMappingURL=chunk-XZFE2YYH.js.map

package/dist/chunk-XZFE2YYH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/flow-button-edge/flow-button-edge.tsx"],"sourcesContent":["import { EdgeLabelRenderer, getBezierPath, type Edge, type EdgeProps } from \"@xyflow/react\";\nimport { Plus } from \"lucide-react\";\nimport { FlowEdgePath } from \"../flow-edge-path\";\n\nexport interface FlowButtonEdgeData extends Record<string, unknown> {\n  /** aria-label for the insert button. @default \"Insert node on edge\" */\n  label?: string;\n  /** Called when the edge's \"+\" button is activated (click, Enter, or Space). */\n  onInsert?: () => void;\n}\n\nexport type BrandFlowButtonEdge = Edge<FlowButtonEdgeData, \"button\">;\n\n/**\n * Branded bezier edge (matching `FlowEdge`'s `--flow-edge` token) with a\n * centered \"+\" button rendered via `EdgeLabelRenderer` at the edge midpoint.\n * Register it in `edgeTypes={{ button: FlowButtonEdge }}` and create edges\n * with `type: \"button\"` and `data: FlowButtonEdgeData`.\n *\n * The button is a real `<button>` with an `aria-label`, keyboard-activatable\n * via native Enter/Space. Fires `data.onInsert?.()` on activation — the\n * typical handler splits the edge: insert a new node between source and\n * target and rewire the two edges (see the \"Insert between\" story).\n */\nexport function FlowButtonEdge({\n  id,\n  sourceX,\n  sourceY,\n  targetX,\n  targetY,\n  sourcePosition,\n  targetPosition,\n  markerEnd,\n  style,\n  data,\n}: EdgeProps<BrandFlowButtonEdge>) {\n  const [edgePath, labelX, labelY] = getBezierPath({\n    sourceX,\n    sourceY,\n    sourcePosition,\n    targetX,\n    targetY,\n    targetPosition,\n  });\n  const label = data?.label ?? \"Insert node on edge\";\n\n  return (\n    <>\n      <FlowEdgePath\n        id={id}\n        path={edgePath}\n        markerEnd={markerEnd}\n        data-slot=\"flow-button-edge\"\n        stroke=\"var(--flow-edge)\"\n        strokeWidth={1.5}\n        style={style}\n      />\n      <EdgeLabelRenderer>\n        <div\n          style={{\n            position: \"absolute\",\n            transform: `translate(-50%, -50%) translate(${labelX}px, ${labelY}px)`,\n          }}\n          className=\"nodrag nopan pointer-events-auto\"\n        >\n          <button\n            type=\"button\"\n            aria-label={label}\n            onClick={() => data?.onInsert?.()}\n            className=\"flex size-5 items-center justify-center rounded-full border border-flow-group-border bg-flow-node text-flow-node-foreground shadow-sm transition-colors duration-fast ease-standard hover:bg-accent hover:text-accent-foreground focus-ring\"\n          >\n            <Plus className=\"size-3\" aria-hidden=\"true\" />\n          </button>\n        </div>\n      </EdgeLabelRenderer>\n    </>\n  );\n}\n"],"mappings":";;;;;;AAAA,SAAS,mBAAmB,qBAAgD;AAC5E,SAAS,YAAY;AA8CjB,mBACE,KADF;AAvBG,SAAS,eAAe;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAmC;AACjC,QAAM,CAAC,UAAU,QAAQ,MAAM,IAAI,cAAc;AAAA,IAC/C;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACD,QAAM,QAAQ,MAAM,SAAS;AAE7B,SACE,iCACE;AAAA;AAAA,MAAC;AAAA;AAAA,QACC;AAAA,QACA,MAAM;AAAA,QACN;AAAA,QACA,aAAU;AAAA,QACV,QAAO;AAAA,QACP,aAAa;AAAA,QACb;AAAA;AAAA,IACF;AAAA,IACA,oBAAC,qBACC;AAAA,MAAC;AAAA;AAAA,QACC,OAAO;AAAA,UACL,UAAU;AAAA,UACV,WAAW,mCAAmC,MAAM,OAAO,MAAM;AAAA,QACnE;AAAA,QACA,WAAU;AAAA,QAEV;AAAA,UAAC;AAAA;AAAA,YACC,MAAK;AAAA,YACL,cAAY;AAAA,YACZ,SAAS,MAAM,MAAM,WAAW;AAAA,YAChC,WAAU;AAAA,YAEV,8BAAC,QAAK,WAAU,UAAS,eAAY,QAAO;AAAA;AAAA,QAC9C;AAAA;AAAA,IACF,GACF;AAAA,KACF;AAEJ;","names":[]}

package/dist/chunk-YG3KXTZW.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-YG3KXTZW.js.map

package/dist/chunk-YG3KXTZW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-ZATVF42E.js

@@ -0,0 +1,65 @@
+"use client";
+import {
+  getHelperLines
+} from "./chunk-DNZRAJAQ.js";
+
+// src/helper-lines/use-helper-lines.ts
+import { useCallback, useState } from "react";
+import { useReactFlow } from "@xyflow/react";
+function nodeRect(node) {
+  return {
+    x: node.position.x,
+    y: node.position.y,
+    width: node.measured?.width ?? node.width ?? 0,
+    height: node.measured?.height ?? node.height ?? 0
+  };
+}
+function useHelperLines(onNodesChange, options = {}) {
+  const { threshold = 5 } = options;
+  const { getNodes } = useReactFlow();
+  const [helperLineHorizontal, setHelperLineHorizontal] = useState();
+  const [helperLineVertical, setHelperLineVertical] = useState();
+  const handleNodesChange = useCallback(
+    (changes) => {
+      let horizontal;
+      let vertical;
+      const dragChanges = changes.filter(
+        (c) => c.type === "position" && c.dragging === true && c.position != null
+      );
+      if (dragChanges.length === 1) {
+        const change = dragChanges[0];
+        const nodes = getNodes();
+        const dragged = change ? nodes.find((n) => n.id === change.id) : void 0;
+        if (change && change.position && dragged) {
+          const draggedRect = {
+            x: change.position.x,
+            y: change.position.y,
+            width: dragged.measured?.width ?? dragged.width ?? 0,
+            height: dragged.measured?.height ?? dragged.height ?? 0
+          };
+          const others = nodes.filter((n) => n.id !== change.id).map(nodeRect);
+          const {
+            snapX,
+            snapY,
+            vertical: v,
+            horizontal: h
+          } = getHelperLines(draggedRect, others, threshold);
+          if (snapX !== void 0) change.position.x = snapX;
+          if (snapY !== void 0) change.position.y = snapY;
+          vertical = v;
+          horizontal = h;
+        }
+      }
+      setHelperLineHorizontal(horizontal);
+      setHelperLineVertical(vertical);
+      onNodesChange?.(changes);
+    },
+    [getNodes, onNodesChange, threshold]
+  );
+  return { onNodesChange: handleNodesChange, helperLineHorizontal, helperLineVertical };
+}
+
+export {
+  useHelperLines
+};
+//# sourceMappingURL=chunk-ZATVF42E.js.map

package/dist/chunk-ZATVF42E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/helper-lines/use-helper-lines.ts"],"sourcesContent":["\"use client\";\n\nimport { useCallback, useState } from \"react\";\nimport { useReactFlow, type Node, type NodeChange } from \"@xyflow/react\";\nimport { getHelperLines, type HelperLineRect } from \"./get-helper-lines\";\n\nexport interface UseHelperLinesOptions {\n  /** Alignment threshold in flow coordinates. Defaults to 5. */\n  threshold?: number;\n}\n\nexport interface UseHelperLinesResult<NodeType extends Node = Node> {\n  /**\n   * Drop-in replacement for the consumer's `onNodesChange`: it snaps a dragged\n   * node onto any near-aligned edge/center, then forwards the (mutated) changes\n   * to the wrapped handler.\n   */\n  onNodesChange: (changes: NodeChange<NodeType>[]) => void;\n  /** Absolute flow-y of the active horizontal guide, or `undefined`. */\n  helperLineHorizontal: number | undefined;\n  /** Absolute flow-x of the active vertical guide, or `undefined`. */\n  helperLineVertical: number | undefined;\n}\n\nfunction nodeRect(node: Node): HelperLineRect {\n  return {\n    x: node.position.x,\n    y: node.position.y,\n    width: node.measured?.width ?? node.width ?? 0,\n    height: node.measured?.height ?? node.height ?? 0,\n  };\n}\n\n/**\n * Decorate a consumer's `onNodesChange` with alignment guides + snapping.\n *\n * While a **single** node is dragged, the returned handler compares its\n * left/center/right and top/middle/bottom against every other node; when a pair\n * is within `threshold` flow px it (a) snaps the dragged node's position change\n * onto the guide and (b) exposes the guide coordinates so `<HelperLines>` can\n * draw them. Guides clear when the drag ends or nothing aligns.\n *\n * Must be called inside a React Flow context (a `<ReactFlowProvider>` or a\n * component rendered under `<ReactFlow>`), since it reads the live node store.\n *\n * @example\n *   const [nodes, , onNodesChange] = useNodesState(initialNodes);\n *   const { onNodesChange: handle, helperLineHorizontal, helperLineVertical } =\n *     useHelperLines(onNodesChange);\n *   // <ReactFlow onNodesChange={handle}>\n *   //   <HelperLines horizontal={helperLineHorizontal} vertical={helperLineVertical} />\n */\nexport function useHelperLines<NodeType extends Node = Node>(\n  onNodesChange?: (changes: NodeChange<NodeType>[]) => void,\n  options: UseHelperLinesOptions = {},\n): UseHelperLinesResult<NodeType> {\n  const { threshold = 5 } = options;\n  const { getNodes } = useReactFlow<NodeType>();\n  const [helperLineHorizontal, setHelperLineHorizontal] = useState<number>();\n  const [helperLineVertical, setHelperLineVertical] = useState<number>();\n\n  const handleNodesChange = useCallback(\n    (changes: NodeChange<NodeType>[]) => {\n      let horizontal: number | undefined;\n      let vertical: number | undefined;\n\n      const dragChanges = changes.filter(\n        (c): c is Extract<NodeChange<NodeType>, { type: \"position\" }> =>\n          c.type === \"position\" && c.dragging === true && c.position != null,\n      );\n\n      // Only guide/snap a single dragged node — multi-select drags are ambiguous.\n      if (dragChanges.length === 1) {\n        const change = dragChanges[0];\n        const nodes = getNodes();\n        const dragged = change ? nodes.find((n) => n.id === change.id) : undefined;\n\n        if (change && change.position && dragged) {\n          const draggedRect: HelperLineRect = {\n            x: change.position.x,\n            y: change.position.y,\n            width: dragged.measured?.width ?? dragged.width ?? 0,\n            height: dragged.measured?.height ?? dragged.height ?? 0,\n          };\n          const others = nodes.filter((n) => n.id !== change.id).map(nodeRect);\n          const {\n            snapX,\n            snapY,\n            vertical: v,\n            horizontal: h,\n          } = getHelperLines(draggedRect, others, threshold);\n\n          // Mutate the position change so the node lands exactly on the guide.\n          if (snapX !== undefined) change.position.x = snapX;\n          if (snapY !== undefined) change.position.y = snapY;\n          vertical = v;\n          horizontal = h;\n        }\n      }\n\n      setHelperLineHorizontal(horizontal);\n      setHelperLineVertical(vertical);\n      onNodesChange?.(changes);\n    },\n    [getNodes, onNodesChange, threshold],\n  );\n\n  return { onNodesChange: handleNodesChange, helperLineHorizontal, helperLineVertical };\n}\n"],"mappings":";;;;;;AAEA,SAAS,aAAa,gBAAgB;AACtC,SAAS,oBAAgD;AAqBzD,SAAS,SAAS,MAA4B;AAC5C,SAAO;AAAA,IACL,GAAG,KAAK,SAAS;AAAA,IACjB,GAAG,KAAK,SAAS;AAAA,IACjB,OAAO,KAAK,UAAU,SAAS,KAAK,SAAS;AAAA,IAC7C,QAAQ,KAAK,UAAU,UAAU,KAAK,UAAU;AAAA,EAClD;AACF;AAqBO,SAAS,eACd,eACA,UAAiC,CAAC,GACF;AAChC,QAAM,EAAE,YAAY,EAAE,IAAI;AAC1B,QAAM,EAAE,SAAS,IAAI,aAAuB;AAC5C,QAAM,CAAC,sBAAsB,uBAAuB,IAAI,SAAiB;AACzE,QAAM,CAAC,oBAAoB,qBAAqB,IAAI,SAAiB;AAErE,QAAM,oBAAoB;AAAA,IACxB,CAAC,YAAoC;AACnC,UAAI;AACJ,UAAI;AAEJ,YAAM,cAAc,QAAQ;AAAA,QAC1B,CAAC,MACC,EAAE,SAAS,cAAc,EAAE,aAAa,QAAQ,EAAE,YAAY;AAAA,MAClE;AAGA,UAAI,YAAY,WAAW,GAAG;AAC5B,cAAM,SAAS,YAAY,CAAC;AAC5B,cAAM,QAAQ,SAAS;AACvB,cAAM,UAAU,SAAS,MAAM,KAAK,CAAC,MAAM,EAAE,OAAO,OAAO,EAAE,IAAI;AAEjE,YAAI,UAAU,OAAO,YAAY,SAAS;AACxC,gBAAM,cAA8B;AAAA,YAClC,GAAG,OAAO,SAAS;AAAA,YACnB,GAAG,OAAO,SAAS;AAAA,YACnB,OAAO,QAAQ,UAAU,SAAS,QAAQ,SAAS;AAAA,YACnD,QAAQ,QAAQ,UAAU,UAAU,QAAQ,UAAU;AAAA,UACxD;AACA,gBAAM,SAAS,MAAM,OAAO,CAAC,MAAM,EAAE,OAAO,OAAO,EAAE,EAAE,IAAI,QAAQ;AACnE,gBAAM;AAAA,YACJ;AAAA,YACA;AAAA,YACA,UAAU;AAAA,YACV,YAAY;AAAA,UACd,IAAI,eAAe,aAAa,QAAQ,SAAS;AAGjD,cAAI,UAAU,OAAW,QAAO,SAAS,IAAI;AAC7C,cAAI,UAAU,OAAW,QAAO,SAAS,IAAI;AAC7C,qBAAW;AACX,uBAAa;AAAA,QACf;AAAA,MACF;AAEA,8BAAwB,UAAU;AAClC,4BAAsB,QAAQ;AAC9B,sBAAgB,OAAO;AAAA,IACzB;AAAA,IACA,CAAC,UAAU,eAAe,SAAS;AAAA,EACrC;AAEA,SAAO,EAAE,eAAe,mBAAmB,sBAAsB,mBAAmB;AACtF;","names":[]}

package/dist/chunk-ZXZTLQIX.js

@@ -0,0 +1,19 @@
+"use client";
+
+// src/flow-weighted-edge/back-edge-geometry.ts
+function backEdgeDetour(rects, axis, span, clearance) {
+  const [lo, hi] = span[0] <= span[1] ? span : [span[1], span[0]];
+  let far = Number.NEGATIVE_INFINITY;
+  for (const rect of rects) {
+    if (!(rect.width > 0) || !(rect.height > 0)) continue;
+    const [near, beyond] = axis === "vertical" ? [rect.y, rect.y + rect.height] : [rect.x, rect.x + rect.width];
+    if (beyond < lo || near > hi) continue;
+    far = Math.max(far, axis === "vertical" ? rect.x + rect.width : rect.y + rect.height);
+  }
+  return Number.isFinite(far) ? far + clearance : null;
+}
+
+export {
+  backEdgeDetour
+};
+//# sourceMappingURL=chunk-ZXZTLQIX.js.map

package/dist/chunk-ZXZTLQIX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/flow-weighted-edge/back-edge-geometry.ts"],"sourcesContent":["/**\n * Where a back edge's return leg runs, so it stays VISIBLE.\n *\n * A back edge is drawn as a smoothstep with one long cross-segment running against the\n * layout direction. React Flow puts that segment halfway between the two handles by\n * default, and a fixed nudge off the midpoint does not help: in a top-down layout the\n * midpoint of a rework edge sits between two ranks, i.e. squarely inside the column of\n * cards it is supposed to run past. Edges paint UNDER nodes, so the segment vanishes\n * behind the cards and all the reader is left with is a dashed stub below one node and\n * another above the other — which reads as a stray rectangle, not as a loop back.\n *\n * So the leg is placed OUTSIDE every card it would otherwise pass behind: past the far\n * side of every node whose extent overlaps the span the edge crosses. That is how a\n * process-mining tool draws a rework loop — out, around the rank, back in — and it is\n * the only placement that is correct for a graph rather than for a pair of nodes.\n */\n\n/** One node's laid-out box, in flow coordinates. */\nexport interface BackEdgeNodeRect {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Which axis the layout's ranks advance along. */\nexport type BackEdgeAxis = \"vertical\" | \"horizontal\";\n\n/**\n * The `centerX` (vertical layout) or `centerY` (horizontal layout) to hand\n * `getSmoothStepPath`, or `null` when nothing is measured yet and React Flow's own\n * midpoint should stand.\n *\n * @param rects  Every laid-out node on the canvas. Nodes that cannot be hit are filtered\n *               out here rather than by the caller, so the caller stays a plain map.\n * @param span   The interval the edge crosses on the RANK axis (`[min, max]` of the two\n *               handle coordinates) — a node outside it is never behind this edge.\n * @param clearance  Gap left between the leg and the outermost card it clears.\n */\nexport function backEdgeDetour(\n  rects: readonly BackEdgeNodeRect[],\n  axis: BackEdgeAxis,\n  span: readonly [number, number],\n  clearance: number,\n): number | null {\n  const [lo, hi] = span[0] <= span[1] ? span : [span[1], span[0]];\n  let far = Number.NEGATIVE_INFINITY;\n\n  for (const rect of rects) {\n    if (!(rect.width > 0) || !(rect.height > 0)) continue;\n    // Overlap on the RANK axis (the one the edge travels along): a node beside the\n    // corridor but on another rank cannot be crossed by this leg.\n    const [near, beyond] =\n      axis === \"vertical\" ? [rect.y, rect.y + rect.height] : [rect.x, rect.x + rect.width];\n    if (beyond < lo || near > hi) continue;\n    far = Math.max(far, axis === \"vertical\" ? rect.x + rect.width : rect.y + rect.height);\n  }\n\n  return Number.isFinite(far) ? far + clearance : null;\n}\n"],"mappings":";;;AAuCO,SAAS,eACd,OACA,MACA,MACA,WACe;AACf,QAAM,CAAC,IAAI,EAAE,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC;AAC9D,MAAI,MAAM,OAAO;AAEjB,aAAW,QAAQ,OAAO;AACxB,QAAI,EAAE,KAAK,QAAQ,MAAM,EAAE,KAAK,SAAS,GAAI;AAG7C,UAAM,CAAC,MAAM,MAAM,IACjB,SAAS,aAAa,CAAC,KAAK,GAAG,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC,KAAK,GAAG,KAAK,IAAI,KAAK,KAAK;AACrF,QAAI,SAAS,MAAM,OAAO,GAAI;AAC9B,UAAM,KAAK,IAAI,KAAK,SAAS,aAAa,KAAK,IAAI,KAAK,QAAQ,KAAK,IAAI,KAAK,MAAM;AAAA,EACtF;AAEA,SAAO,OAAO,SAAS,GAAG,IAAI,MAAM,YAAY;AAClD;","names":[]}

package/dist/flow-button-edge/flow-button-edge.js

@@ -0,0 +1,10 @@
+"use client";
+import {
+  FlowButtonEdge
+} from "../chunk-XZFE2YYH.js";
+import "../chunk-KDVMGMAK.js";
+import "../chunk-SXXJV6YJ.js";
+export {
+  FlowButtonEdge
+};
+//# sourceMappingURL=flow-button-edge.js.map

package/dist/flow-button-edge/flow-button-edge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/flow-button-edge/index.js

@@ -0,0 +1,11 @@
+"use client";
+import "../chunk-B6IUPZU7.js";
+import {
+  FlowButtonEdge
+} from "../chunk-XZFE2YYH.js";
+import "../chunk-KDVMGMAK.js";
+import "../chunk-SXXJV6YJ.js";
+export {
+  FlowButtonEdge
+};
+//# sourceMappingURL=index.js.map

package/dist/flow-button-edge/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/flow-edge/flow-edge.js

@@ -0,0 +1,10 @@
+"use client";
+import {
+  FlowEdge
+} from "../chunk-SHCZK4DO.js";
+import "../chunk-KDVMGMAK.js";
+import "../chunk-SXXJV6YJ.js";
+export {
+  FlowEdge
+};
+//# sourceMappingURL=flow-edge.js.map

package/dist/flow-edge/flow-edge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/flow-edge/index.js

@@ -0,0 +1,11 @@
+"use client";
+import "../chunk-ELCLRVD4.js";
+import {
+  FlowEdge
+} from "../chunk-SHCZK4DO.js";
+import "../chunk-KDVMGMAK.js";
+import "../chunk-SXXJV6YJ.js";
+export {
+  FlowEdge
+};
+//# sourceMappingURL=index.js.map