@pipelex/mthds-ui 0.5.0

package/dist/chunk-CCUSQM3E.js

@@ -0,0 +1,1155 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-DDAAVRWG.js";
+
+// src/graph/types.ts
+var NODE_TYPE_PIPE_CARD = "pipeCard";
+var NODE_TYPE_STUFF = "default";
+var NODE_TYPE_CONTROLLER = "controllerGroup";
+var STUFF_ID_PREFIX = "stuff_";
+function stuffNodeId(digest) {
+  return STUFF_ID_PREFIX + digest;
+}
+function isStuffNodeId(id) {
+  return id.startsWith(STUFF_ID_PREFIX);
+}
+function stuffDigestFromId(id) {
+  return id.slice(STUFF_ID_PREFIX.length);
+}
+var GRAPH_DIRECTION = {
+  TB: "TB",
+  BT: "BT",
+  LR: "LR",
+  RL: "RL"
+};
+var EDGE_TYPE = {
+  /** Bezier curve — ReactFlow v12 renamed this type from "bezier" to "default". */
+  DEFAULT: "default",
+  STEP: "step",
+  STRAIGHT: "straight",
+  SMOOTH_STEP: "smoothstep"
+};
+var CONTROLLER_PADDING_X = 40;
+var CONTROLLER_PADDING_TOP = 48;
+var CONTROLLER_PADDING_BOTTOM = 20;
+var ARROW_CLOSED_MARKER = "arrowclosed";
+function nodeWidth(n) {
+  var _a;
+  const raw = (_a = n.style) == null ? void 0 : _a.width;
+  if (raw == null) return 200;
+  const w = typeof raw === "number" ? raw : parseFloat(raw);
+  return isNaN(w) || w <= 0 ? 200 : w;
+}
+function nodeHeight(n) {
+  var _a, _b;
+  const raw = (_a = n.style) == null ? void 0 : _a.height;
+  if (raw != null) {
+    const h = typeof raw === "number" ? raw : parseFloat(raw);
+    if (!isNaN(h) && h > 0) return h;
+  }
+  return ((_b = n.data) == null ? void 0 : _b.isStuff) ? 60 : 70;
+}
+
+// src/graph/graphAnalysis.ts
+function buildDataflowAnalysis(graphspec) {
+  if (!graphspec) return null;
+  const stuffRegistry = {};
+  const stuffProducers = {};
+  const stuffConsumers = {};
+  const containmentTree = {};
+  const childNodeIds = /* @__PURE__ */ new Set();
+  for (const edge of graphspec.edges) {
+    if (edge.kind === "contains") {
+      if (!containmentTree[edge.source]) containmentTree[edge.source] = [];
+      containmentTree[edge.source].push(edge.target);
+      childNodeIds.add(edge.target);
+    }
+  }
+  const controllerNodeIds = new Set(Object.keys(containmentTree));
+  for (const node of graphspec.nodes) {
+    const nodeIo = node.io || {};
+    const isController = controllerNodeIds.has(node.id);
+    for (const output of nodeIo.outputs || []) {
+      if (output.digest && !stuffRegistry[output.digest]) {
+        stuffRegistry[output.digest] = {
+          name: output.name,
+          concept: output.concept,
+          contentType: output.content_type
+        };
+      }
+      if (output.digest && !isController) {
+        stuffProducers[output.digest] = node.id;
+      }
+    }
+    for (const input of nodeIo.inputs || []) {
+      if (input.digest && !stuffRegistry[input.digest]) {
+        stuffRegistry[input.digest] = {
+          name: input.name,
+          concept: input.concept,
+          contentType: input.content_type
+        };
+      }
+      if (input.digest && !isController) {
+        if (!stuffConsumers[input.digest]) stuffConsumers[input.digest] = [];
+        stuffConsumers[input.digest].push(node.id);
+      }
+    }
+  }
+  return {
+    stuffRegistry,
+    stuffProducers,
+    stuffConsumers,
+    controllerNodeIds,
+    childNodeIds,
+    containmentTree
+  };
+}
+function buildChildToControllerMap(graphspec, analysis) {
+  var _a;
+  const childToController = {};
+  for (const [ctrlId, children] of Object.entries(analysis.containmentTree)) {
+    for (const childId of children) {
+      childToController[childId] = ctrlId;
+    }
+  }
+  for (const [digest, producerId] of Object.entries(analysis.stuffProducers)) {
+    const stuffId = "stuff_" + digest;
+    const ctrlId = childToController[producerId];
+    if (ctrlId) {
+      childToController[stuffId] = ctrlId;
+    }
+  }
+  for (const node of graphspec.nodes) {
+    if (!analysis.controllerNodeIds.has(node.id)) continue;
+    const parentCtrlId = childToController[node.id];
+    if (!parentCtrlId) continue;
+    for (const output of ((_a = node.io) == null ? void 0 : _a.outputs) || []) {
+      if (!output.digest) continue;
+      const stuffId = "stuff_" + output.digest;
+      if (!childToController[stuffId]) {
+        childToController[stuffId] = parentCtrlId;
+      }
+    }
+  }
+  for (const edge of graphspec.edges) {
+    if (edge.kind === "batch_item" && edge.target_stuff_digest) {
+      const stuffId = "stuff_" + edge.target_stuff_digest;
+      if (analysis.controllerNodeIds.has(edge.source)) {
+        childToController[stuffId] = edge.source;
+      }
+    }
+  }
+  const stuffInStuffEdges = /* @__PURE__ */ new Set();
+  for (const edge of graphspec.edges) {
+    if (edge.kind === "batch_item" || edge.kind === "batch_aggregate" || edge.kind === "parallel_combine") {
+      if (edge.source_stuff_digest) stuffInStuffEdges.add(edge.source_stuff_digest);
+      if (edge.target_stuff_digest) stuffInStuffEdges.add(edge.target_stuff_digest);
+    }
+  }
+  const stuffPrefix = "stuff_";
+  const stuffEntries = Object.keys(childToController).filter((id) => id.startsWith(stuffPrefix));
+  for (const stuffId of stuffEntries) {
+    const digest = stuffId.slice(stuffPrefix.length);
+    let assignedCtrl = childToController[stuffId];
+    if (!assignedCtrl) continue;
+    const consumers = analysis.stuffConsumers[digest] || [];
+    if (consumers.length === 0) {
+      if (!stuffInStuffEdges.has(digest)) {
+        delete childToController[stuffId];
+      }
+      continue;
+    }
+    while (assignedCtrl) {
+      const ctrl = assignedCtrl;
+      const hasConsumerInside = consumers.some(
+        (consumerId) => isDescendantOf(consumerId, ctrl, childToController)
+      );
+      if (hasConsumerInside) break;
+      const parentCtrl = childToController[assignedCtrl];
+      if (parentCtrl) {
+        childToController[stuffId] = parentCtrl;
+        assignedCtrl = parentCtrl;
+      } else {
+        delete childToController[stuffId];
+        assignedCtrl = void 0;
+      }
+    }
+  }
+  return childToController;
+}
+function isDescendantOf(nodeId, ancestorCtrlId, childToController) {
+  let current = childToController[nodeId];
+  while (current) {
+    if (current === ancestorCtrlId) return true;
+    current = childToController[current];
+  }
+  return false;
+}
+function getPipeBlueprint(spec, pipeRef) {
+  var _a;
+  return (_a = spec.pipe_registry) == null ? void 0 : _a[pipeRef];
+}
+function getConceptInfo(spec, conceptRef) {
+  var _a;
+  return (_a = spec.concept_registry) == null ? void 0 : _a[conceptRef];
+}
+function resolveConceptRef(spec, codeOrRef) {
+  if (!spec.concept_registry) return void 0;
+  const direct = spec.concept_registry[codeOrRef];
+  if (direct) return direct;
+  for (const info of Object.values(spec.concept_registry)) {
+    if (info.code === codeOrRef) return info;
+  }
+  return void 0;
+}
+
+// src/graph/graphBuilders.ts
+function defaultDescription(pipeType, pipeCode) {
+  const code = pipeCode || "this step";
+  const verb = {
+    PipeLLM: "Analyze and generate output using",
+    PipeExtract: "Extract content from",
+    PipeCompose: "Compose output using",
+    PipeImgGen: "Generate image for",
+    PipeSearch: "Search the web for",
+    PipeFunc: "Process data in"
+  };
+  return `${verb[pipeType || ""] || "Execute"} ${code.replace(/_/g, " ")}`;
+}
+var STUFF_CHAR_WIDTH_PX = 7;
+var STUFF_LABEL_PADDING = 48;
+var MIN_STUFF_WIDTH = 140;
+function buildDataflowGraph(graphspec, analysis, edgeType) {
+  var _a, _b, _c, _d, _e;
+  const nodes = [];
+  const edges = [];
+  const participatingPipes = /* @__PURE__ */ new Set();
+  for (const producer of Object.values(analysis.stuffProducers)) {
+    participatingPipes.add(producer);
+  }
+  for (const consumers of Object.values(analysis.stuffConsumers)) {
+    for (const consumer of consumers) {
+      participatingPipes.add(consumer);
+    }
+  }
+  for (const node of graphspec.nodes) {
+    if (!participatingPipes.has(node.id)) continue;
+    const isFailed = node.status === "failed";
+    const label = node.pipe_code || node.id.split(":").pop() || node.id;
+    const inputs = ((_b = (_a = node.io) == null ? void 0 : _a.inputs) != null ? _b : []).map((i) => {
+      var _a2, _b2;
+      return {
+        name: (_a2 = i.name) != null ? _a2 : "",
+        concept: (_b2 = i.concept) != null ? _b2 : ""
+      };
+    });
+    const outputs = ((_d = (_c = node.io) == null ? void 0 : _c.outputs) != null ? _d : []).map((o) => {
+      var _a2, _b2;
+      return {
+        name: (_a2 = o.name) != null ? _a2 : "",
+        concept: (_b2 = o.concept) != null ? _b2 : ""
+      };
+    });
+    const operatorType = node.pipe_type || "PipeFunc";
+    nodes.push({
+      id: node.id,
+      type: NODE_TYPE_PIPE_CARD,
+      data: {
+        labelDescriptor: { kind: "pipe", label, isFailed },
+        nodeData: node,
+        isPipe: true,
+        isStuff: false,
+        labelText: label,
+        pipeCode: node.pipe_code || label,
+        pipeType: node.pipe_type,
+        pipeCardData: {
+          pipeCode: node.pipe_code || label,
+          pipeType: operatorType,
+          description: node.description || defaultDescription(node.pipe_type, node.pipe_code),
+          status: node.status || "scheduled",
+          inputs,
+          outputs
+        }
+      },
+      position: { x: 0, y: 0 }
+    });
+  }
+  for (const [digest, stuffInfo] of Object.entries(analysis.stuffRegistry)) {
+    const stuffId = stuffNodeId(digest);
+    const label = stuffInfo.name || "data";
+    const concept = stuffInfo.concept || "";
+    const textWidth = Math.max(label.length, concept.length) * STUFF_CHAR_WIDTH_PX + STUFF_LABEL_PADDING;
+    const stuffWidth = Math.max(MIN_STUFF_WIDTH, textWidth);
+    const isInput = !analysis.stuffProducers[digest];
+    const isOutput = !isInput && !((_e = analysis.stuffConsumers[digest]) == null ? void 0 : _e.length);
+    const stuffRole = isInput ? "input" : isOutput ? "output" : void 0;
+    const borderColor = isInput ? "var(--color-stuff-input-border, #50FA7B)" : isOutput ? "var(--color-stuff-output-border, #a78bfa)" : "var(--color-stuff-border)";
+    nodes.push({
+      id: stuffId,
+      type: NODE_TYPE_STUFF,
+      data: {
+        labelDescriptor: { kind: "stuff", label, concept },
+        isStuff: true,
+        isPipe: false,
+        labelText: label,
+        stuffRole,
+        stuffDigest: digest
+      },
+      position: { x: 0, y: 0 },
+      style: {
+        background: "var(--color-stuff-bg)",
+        border: `2px solid ${borderColor}`,
+        borderRadius: "999px",
+        padding: "0",
+        width: stuffWidth + "px",
+        boxShadow: "var(--shadow-md)"
+      }
+    });
+  }
+  let edgeId = 0;
+  for (const [digest, producerNodeId] of Object.entries(analysis.stuffProducers)) {
+    const stuffId = stuffNodeId(digest);
+    edges.push({
+      id: "edge_" + edgeId++,
+      source: producerNodeId,
+      target: stuffId,
+      type: edgeType,
+      animated: false,
+      style: { stroke: "var(--color-edge)", strokeWidth: 2 },
+      markerEnd: {
+        type: ARROW_CLOSED_MARKER,
+        color: "var(--color-edge)"
+      }
+    });
+  }
+  for (const [digest, consumers] of Object.entries(analysis.stuffConsumers)) {
+    const stuffId = stuffNodeId(digest);
+    for (const consumerNodeId of consumers) {
+      edges.push({
+        id: "edge_" + edgeId++,
+        source: stuffId,
+        target: consumerNodeId,
+        type: edgeType,
+        animated: false,
+        style: { stroke: "var(--color-edge)", strokeWidth: 2 },
+        markerEnd: {
+          type: ARROW_CLOSED_MARKER,
+          color: "var(--color-edge)"
+        }
+      });
+    }
+  }
+  for (const edge of graphspec.edges) {
+    if (edge.kind !== "parallel_combine") continue;
+    if (!edge.source_stuff_digest || !edge.target_stuff_digest) continue;
+    if (!analysis.stuffRegistry[edge.source_stuff_digest] || !analysis.stuffRegistry[edge.target_stuff_digest])
+      continue;
+    const sourceId = stuffNodeId(edge.source_stuff_digest);
+    const targetId = stuffNodeId(edge.target_stuff_digest);
+    edges.push({
+      id: edge.id || "edge_" + edgeId++,
+      source: sourceId,
+      target: targetId,
+      type: "smoothstep",
+      animated: false,
+      style: {
+        stroke: "var(--color-parallel-combine)",
+        strokeWidth: 2,
+        strokeDasharray: "5,5"
+      },
+      markerEnd: {
+        type: ARROW_CLOSED_MARKER,
+        color: "var(--color-parallel-combine)"
+      }
+    });
+  }
+  for (const edge of graphspec.edges) {
+    if (edge.kind !== "batch_item" && edge.kind !== "batch_aggregate") continue;
+    if (!edge.source_stuff_digest || !edge.target_stuff_digest) continue;
+    if (!analysis.stuffRegistry[edge.source_stuff_digest] || !analysis.stuffRegistry[edge.target_stuff_digest])
+      continue;
+    const sourceId = stuffNodeId(edge.source_stuff_digest);
+    const targetId = stuffNodeId(edge.target_stuff_digest);
+    const isBatchItem = edge.kind === "batch_item";
+    edges.push({
+      id: edge.id || "edge_" + edgeId++,
+      source: sourceId,
+      target: targetId,
+      type: edgeType,
+      animated: false,
+      _batchEdge: true,
+      label: edge.label || "",
+      labelStyle: {
+        fontSize: "10px",
+        fontFamily: "var(--font-mono)",
+        fill: isBatchItem ? "var(--color-batch-item)" : "var(--color-batch-aggregate)"
+      },
+      labelBgStyle: { fill: "var(--color-bg)", fillOpacity: 0.9 },
+      style: {
+        stroke: isBatchItem ? "var(--color-batch-item)" : "var(--color-batch-aggregate)",
+        strokeWidth: 2,
+        strokeDasharray: "5,5"
+      },
+      markerEnd: {
+        type: ARROW_CLOSED_MARKER,
+        color: isBatchItem ? "var(--color-batch-item)" : "var(--color-batch-aggregate)"
+      }
+    });
+  }
+  const childToCtrl = buildChildToControllerMap(graphspec, analysis);
+  for (const edge of edges) {
+    const srcCtrl = childToCtrl[edge.source] || null;
+    const tgtCtrl = childToCtrl[edge.target] || null;
+    if (srcCtrl && tgtCtrl && srcCtrl !== tgtCtrl) {
+      edge._crossGroup = true;
+      edge.style = __spreadProps(__spreadValues({}, edge.style), {
+        strokeWidth: 1.5,
+        opacity: 0.65
+      });
+    }
+  }
+  for (const edge of edges) {
+    if (edge._batchEdge) {
+      edge.style = __spreadProps(__spreadValues({}, edge.style), {
+        opacity: 0.7
+      });
+    }
+  }
+  return { nodes, edges };
+}
+function buildGraph(graphspec, edgeType) {
+  if (graphspec) {
+    const analysis = buildDataflowAnalysis(graphspec);
+    if (analysis && (Object.keys(analysis.stuffProducers).length > 0 || Object.keys(analysis.stuffConsumers).length > 0)) {
+      return { graphData: buildDataflowGraph(graphspec, analysis, edgeType), analysis };
+    }
+  }
+  return { graphData: { nodes: [], edges: [] }, analysis: null };
+}
+
+// src/graph/elkGraphBuilder.ts
+function elkDirection(direction) {
+  switch (direction) {
+    case "LR":
+      return "RIGHT";
+    case "RL":
+      return "LEFT";
+    case "BT":
+      return "UP";
+    default:
+      return "DOWN";
+  }
+}
+var INPUT_PORT_SUFFIX = "_in";
+var OUTPUT_PORT_SUFFIX = "_out";
+function inputPortId(nodeId) {
+  return nodeId + INPUT_PORT_SUFFIX;
+}
+function outputPortId(nodeId) {
+  return nodeId + OUTPUT_PORT_SUFFIX;
+}
+function makePorts(nodeId, dims, direction) {
+  const portSides = {
+    LR: { inSide: "WEST", outSide: "EAST" },
+    RL: { inSide: "EAST", outSide: "WEST" },
+    TB: { inSide: "NORTH", outSide: "SOUTH" },
+    BT: { inSide: "SOUTH", outSide: "NORTH" }
+  };
+  const { inSide, outSide } = portSides[direction];
+  const isHorizontal = direction === "LR" || direction === "RL";
+  const inX = isHorizontal ? direction === "LR" ? 0 : dims.width : dims.width / 2;
+  const inY = isHorizontal ? dims.height / 2 : direction === "TB" ? 0 : dims.height;
+  const outX = isHorizontal ? direction === "LR" ? dims.width : 0 : dims.width / 2;
+  const outY = isHorizontal ? dims.height / 2 : direction === "TB" ? dims.height : 0;
+  return [
+    {
+      id: inputPortId(nodeId),
+      x: inX,
+      y: inY,
+      width: 1,
+      height: 1,
+      layoutOptions: { "elk.port.side": inSide }
+    },
+    {
+      id: outputPortId(nodeId),
+      x: outX,
+      y: outY,
+      width: 1,
+      height: 1,
+      layoutOptions: { "elk.port.side": outSide }
+    }
+  ];
+}
+var PIPE_CARD_HEIGHT_CAP = 320;
+var PIPE_CARD_PADDING_X = 28;
+var PIPE_CARD_PADDING_Y = 24;
+var PIPE_CARD_GAP = 8;
+var PIPE_CARD_HEADER_HEIGHT = 22;
+var PIPE_CARD_DESC_LINE_HEIGHT = 16;
+var PIPE_CARD_DESC_MAX_LINES_LR = 3;
+var PIPE_CARD_IO_SECTION_HEIGHT_LR = 38;
+var PIPE_CARD_IO_SECTION_HEIGHT_TB = 30;
+var PIPE_CARD_IO_EXTRA_ROW_HEIGHT = 22;
+var PIPE_CARD_PILL_NAME_MAX_WIDTH = 140;
+var PIPE_CARD_PILL_CONCEPT_MAX_WIDTH = 100;
+var PIPE_CARD_PILL_CHROME_WIDTH = 17;
+var PIPE_CARD_IO_LABEL_WIDTH_TB = 58;
+var CHAR_WIDTH_DESC = 5.5;
+var CHAR_WIDTH_PILL_NAME = 5;
+var CHAR_WIDTH_PILL_CONCEPT = 4.5;
+var MAX_VISIBLE_INPUTS = 4;
+function estimateDescriptionLines(description, isHorizontal, cardWidth) {
+  if (!description) return 0;
+  if (!isHorizontal) return 1;
+  const textWidth = cardWidth - PIPE_CARD_PADDING_X;
+  const charsPerLine = Math.max(1, Math.floor(textWidth / CHAR_WIDTH_DESC));
+  const neededLines = Math.ceil(description.length / charsPerLine);
+  return Math.min(PIPE_CARD_DESC_MAX_LINES_LR, Math.max(1, neededLines));
+}
+function estimateTbPillWidth(name, concept) {
+  const nameWidth = Math.min(
+    PIPE_CARD_PILL_NAME_MAX_WIDTH,
+    Math.ceil(name.length * CHAR_WIDTH_PILL_NAME)
+  );
+  const conceptWidth = Math.min(
+    PIPE_CARD_PILL_CONCEPT_MAX_WIDTH,
+    Math.ceil(concept.length * CHAR_WIDTH_PILL_CONCEPT)
+  );
+  return nameWidth + conceptWidth + PIPE_CARD_PILL_CHROME_WIDTH;
+}
+function countTbPillRows(pills, cardWidth) {
+  if (pills.length === 0) return 0;
+  const availableWidth = cardWidth - PIPE_CARD_PADDING_X - PIPE_CARD_IO_LABEL_WIDTH_TB;
+  let rows = 1;
+  let currentRowWidth = 0;
+  for (const pill of pills) {
+    const pillWidth = estimateTbPillWidth(pill.name, pill.concept);
+    if (currentRowWidth === 0) {
+      currentRowWidth = pillWidth;
+      continue;
+    }
+    if (currentRowWidth + pillWidth <= availableWidth) {
+      currentRowWidth += pillWidth;
+    } else {
+      rows += 1;
+      currentRowWidth = pillWidth;
+    }
+  }
+  return rows;
+}
+function estimateNodeDimensions(node, isHorizontal) {
+  var _a, _b, _c;
+  const nodeData = node.data || {};
+  const isStuff = nodeData.isStuff;
+  const labelText = nodeData.labelText || "";
+  const isPipeCard = node.type === NODE_TYPE_PIPE_CARD;
+  const pipeCardMinWidth = isHorizontal ? 180 : 280;
+  const pipeCardMaxWidth = isHorizontal ? 240 : 400;
+  const estimatedWidth = Math.max(180, Math.min(pipeCardMaxWidth, labelText.length * 8 + 60));
+  let width;
+  if (isStuff) {
+    width = Math.max(180, estimatedWidth);
+  } else if (isPipeCard && nodeData.pipeCardData) {
+    width = pipeCardMaxWidth;
+  } else {
+    width = Math.max(isPipeCard ? pipeCardMinWidth : 200, estimatedWidth);
+  }
+  let height;
+  if (isStuff) {
+    height = 60;
+  } else if (isPipeCard && nodeData.pipeCardData) {
+    const pcd = nodeData.pipeCardData;
+    const inputs = (_a = pcd.inputs) != null ? _a : [];
+    const outputs = (_b = pcd.outputs) != null ? _b : [];
+    const description = pcd.description || ((_c = nodeData.nodeData) == null ? void 0 : _c.description) || "";
+    let total = PIPE_CARD_PADDING_Y + PIPE_CARD_HEADER_HEIGHT;
+    const descLines = estimateDescriptionLines(description, isHorizontal, width);
+    if (descLines > 0) {
+      total += PIPE_CARD_GAP + descLines * PIPE_CARD_DESC_LINE_HEIGHT;
+    }
+    const visibleInputs = inputs.slice(0, MAX_VISIBLE_INPUTS);
+    if (visibleInputs.length > 0) {
+      total += PIPE_CARD_GAP;
+      if (isHorizontal) {
+        total += PIPE_CARD_IO_SECTION_HEIGHT_LR + (visibleInputs.length - 1) * PIPE_CARD_IO_EXTRA_ROW_HEIGHT;
+      } else {
+        const rows = countTbPillRows(visibleInputs, width);
+        total += PIPE_CARD_IO_SECTION_HEIGHT_TB + (rows - 1) * PIPE_CARD_IO_EXTRA_ROW_HEIGHT;
+      }
+    }
+    if (outputs.length > 0) {
+      total += PIPE_CARD_GAP;
+      if (isHorizontal) {
+        total += PIPE_CARD_IO_SECTION_HEIGHT_LR + (outputs.length - 1) * PIPE_CARD_IO_EXTRA_ROW_HEIGHT;
+      } else {
+        const rows = countTbPillRows(outputs, width);
+        total += PIPE_CARD_IO_SECTION_HEIGHT_TB + (rows - 1) * PIPE_CARD_IO_EXTRA_ROW_HEIGHT;
+      }
+    }
+    height = Math.min(PIPE_CARD_HEIGHT_CAP, total);
+  } else {
+    height = isPipeCard ? 120 : 70;
+  }
+  return { width, height };
+}
+function computeDepths(controllerNodeIds, containmentTree) {
+  const depthCache = {};
+  const visiting = /* @__PURE__ */ new Set();
+  function getDepth(ctrlId) {
+    if (depthCache[ctrlId] !== void 0) return depthCache[ctrlId];
+    if (visiting.has(ctrlId)) return 0;
+    visiting.add(ctrlId);
+    const children = containmentTree[ctrlId] || [];
+    let maxChildDepth = -1;
+    for (const childId of children) {
+      if (controllerNodeIds.has(childId)) {
+        maxChildDepth = Math.max(maxChildDepth, getDepth(childId));
+      }
+    }
+    visiting.delete(ctrlId);
+    depthCache[ctrlId] = maxChildDepth + 1;
+    return depthCache[ctrlId];
+  }
+  for (const id of controllerNodeIds) getDepth(id);
+  return depthCache;
+}
+function makeLeafNode(nodeId, dims, direction) {
+  return {
+    id: nodeId,
+    width: dims.width,
+    height: dims.height,
+    ports: makePorts(nodeId, dims, direction),
+    layoutOptions: {
+      "elk.portConstraints": "FIXED_POS"
+    }
+  };
+}
+function buildElkGraph(nodes, edges, graphspec, analysis, direction, layoutConfig) {
+  var _a, _b, _c;
+  const isHorizontal = direction === "LR" || direction === "RL";
+  const nodesep = (_a = layoutConfig == null ? void 0 : layoutConfig.nodesep) != null ? _a : 80;
+  const ranksep = (_b = layoutConfig == null ? void 0 : layoutConfig.ranksep) != null ? _b : 70;
+  const elkDir = elkDirection(direction);
+  const edgeNodeSpacing = "30";
+  const rootLayoutOptions = {
+    "elk.algorithm": "layered",
+    "elk.direction": elkDir,
+    "elk.hierarchyHandling": "INCLUDE_CHILDREN",
+    "elk.spacing.nodeNode": String(nodesep),
+    "elk.layered.spacing.nodeNodeBetweenLayers": String(ranksep),
+    "elk.spacing.edgeNode": edgeNodeSpacing,
+    "elk.spacing.edgeEdge": "20",
+    "elk.layered.spacing.edgeNodeBetweenLayers": edgeNodeSpacing,
+    "elk.layered.spacing.edgeEdgeBetweenLayers": "15",
+    "elk.layered.nodePlacement.favorStraightEdges": "true"
+  };
+  if (!graphspec || !analysis || analysis.controllerNodeIds.size === 0) {
+    const dimensionMap2 = {};
+    const elkChildren = nodes.map((node) => {
+      const dims = estimateNodeDimensions(node, isHorizontal);
+      dimensionMap2[node.id] = dims;
+      return makeLeafNode(node.id, dims, direction);
+    });
+    const elkEdges2 = edges.map((edge) => ({
+      id: edge.id,
+      sources: [outputPortId(edge.source)],
+      targets: [inputPortId(edge.target)]
+    }));
+    return {
+      elkGraph: {
+        id: "root",
+        layoutOptions: rootLayoutOptions,
+        children: elkChildren,
+        edges: elkEdges2
+      },
+      dimensionMap: dimensionMap2
+    };
+  }
+  const childToCtrl = buildChildToControllerMap(graphspec, analysis);
+  const depths = computeDepths(analysis.controllerNodeIds, analysis.containmentTree);
+  const dimensionMap = {};
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const node of nodes) nodeById.set(node.id, node);
+  const controllerElkNodes = {};
+  const controllerIds = Array.from(analysis.controllerNodeIds);
+  controllerIds.sort((a, b) => {
+    var _a2, _b2;
+    return ((_a2 = depths[a]) != null ? _a2 : 0) - ((_b2 = depths[b]) != null ? _b2 : 0);
+  });
+  for (const ctrlId of controllerIds) {
+    const depth = (_c = depths[ctrlId]) != null ? _c : 0;
+    const depthScale = 1 + depth * 0.15;
+    const padX = Math.round(CONTROLLER_PADDING_X * depthScale);
+    const padTop = Math.round(CONTROLLER_PADDING_TOP * depthScale);
+    const padBottom = Math.round(CONTROLLER_PADDING_BOTTOM * depthScale);
+    const ctrlLayoutOptions = {
+      "elk.padding": `[top=${padTop},left=${padX},bottom=${padBottom},right=${padX}]`,
+      "elk.spacing.nodeNode": String(nodesep),
+      "elk.layered.spacing.nodeNodeBetweenLayers": String(ranksep),
+      "elk.spacing.edgeNode": edgeNodeSpacing,
+      "elk.layered.spacing.edgeNodeBetweenLayers": edgeNodeSpacing
+    };
+    const children = [];
+    const directChildren = analysis.containmentTree[ctrlId] || [];
+    for (const childId of directChildren) {
+      if (analysis.controllerNodeIds.has(childId)) {
+        const childElk = controllerElkNodes[childId];
+        if (childElk) children.push(childElk);
+      } else {
+        const graphNode = nodeById.get(childId);
+        if (graphNode) {
+          const dims = estimateNodeDimensions(graphNode, isHorizontal);
+          dimensionMap[childId] = dims;
+          children.push(makeLeafNode(childId, dims, direction));
+        }
+      }
+    }
+    for (const node of nodes) {
+      if (node.data.isStuff && childToCtrl[node.id] === ctrlId) {
+        if (!children.some((c) => c.id === node.id)) {
+          const dims = estimateNodeDimensions(node, isHorizontal);
+          dimensionMap[node.id] = dims;
+          children.push(makeLeafNode(node.id, dims, direction));
+        }
+      }
+    }
+    controllerElkNodes[ctrlId] = {
+      id: ctrlId,
+      layoutOptions: ctrlLayoutOptions,
+      children
+    };
+  }
+  const rootChildren = [];
+  for (const ctrlId of controllerIds) {
+    if (!childToCtrl[ctrlId]) {
+      const elkNode = controllerElkNodes[ctrlId];
+      if (elkNode) rootChildren.push(elkNode);
+    }
+  }
+  for (const node of nodes) {
+    if (!childToCtrl[node.id] && !analysis.controllerNodeIds.has(node.id)) {
+      const dims = estimateNodeDimensions(node, isHorizontal);
+      dimensionMap[node.id] = dims;
+      rootChildren.push(makeLeafNode(node.id, dims, direction));
+    }
+  }
+  const nodeIdSet = new Set(nodes.map((n) => n.id));
+  const elkEdges = edges.filter((e) => nodeIdSet.has(e.source) && nodeIdSet.has(e.target)).map((edge) => ({
+    id: edge.id,
+    sources: [outputPortId(edge.source)],
+    targets: [inputPortId(edge.target)]
+  }));
+  return {
+    elkGraph: {
+      id: "root",
+      layoutOptions: rootLayoutOptions,
+      children: rootChildren,
+      edges: elkEdges
+    },
+    dimensionMap
+  };
+}
+function extractAbsolutePositions(elkResult) {
+  const positions = {};
+  function walk(node, parentX, parentY) {
+    var _a, _b, _c, _d, _e;
+    const absX = parentX + ((_a = node.x) != null ? _a : 0);
+    const absY = parentY + ((_b = node.y) != null ? _b : 0);
+    if (node.id !== "root") {
+      positions[node.id] = {
+        x: absX,
+        y: absY,
+        width: (_c = node.width) != null ? _c : 0,
+        height: (_d = node.height) != null ? _d : 0
+      };
+    }
+    for (const child of (_e = node.children) != null ? _e : []) {
+      walk(child, absX, absY);
+    }
+  }
+  walk(elkResult, 0, 0);
+  return positions;
+}
+
+// src/graph/graphLayout.ts
+import ELK from "elkjs/lib/elk.bundled.js";
+var elkInstance = null;
+function getElk() {
+  if (!elkInstance) elkInstance = new ELK();
+  return elkInstance;
+}
+async function getLayoutedElements(nodes, edges, direction, layoutConfig, graphspec, analysis) {
+  if (nodes.length === 0) return { nodes: [], edges, controllerPositions: {} };
+  const isHorizontal = direction === "LR" || direction === "RL";
+  const { elkGraph, dimensionMap } = buildElkGraph(
+    nodes,
+    edges,
+    graphspec != null ? graphspec : null,
+    analysis != null ? analysis : null,
+    direction,
+    layoutConfig
+  );
+  const layoutResult = await getElk().layout(elkGraph);
+  const positions = extractAbsolutePositions(layoutResult);
+  const controllerPositions = {};
+  if (analysis) {
+    for (const ctrlId of analysis.controllerNodeIds) {
+      if (positions[ctrlId]) {
+        controllerPositions[ctrlId] = positions[ctrlId];
+      }
+    }
+  }
+  const result = nodes.map((node) => {
+    var _a;
+    const pos = positions[node.id];
+    const dims = (_a = dimensionMap[node.id]) != null ? _a : estimateNodeDimensions(node, isHorizontal);
+    const width = dims.width;
+    const height = dims.height;
+    const pipeCardData = node.data.pipeCardData;
+    const cardDirection = isHorizontal ? "LR" : "TB";
+    const updatedPipeCardData = pipeCardData ? __spreadProps(__spreadValues({}, pipeCardData), { direction: cardDirection }) : void 0;
+    return __spreadProps(__spreadValues({}, node), {
+      data: __spreadProps(__spreadValues({}, node.data), {
+        _estimatedWidth: width,
+        _estimatedHeight: height,
+        pipeCardData: updatedPipeCardData
+      }),
+      // Lock the ReactFlow node wrapper to the exact dimensions ELK used for layout.
+      // This ensures ReactFlow's Handle (centered on the DOM element) matches
+      // the port position ELK computed (centered on the estimated dimensions).
+      style: __spreadProps(__spreadValues({}, node.style), {
+        width: width + "px",
+        height: height + "px"
+      }),
+      position: {
+        x: pos ? pos.x : 0,
+        y: pos ? pos.y : 0
+      },
+      sourcePosition: isHorizontal ? direction === "LR" ? "right" : "left" : direction === "TB" ? "bottom" : "top",
+      targetPosition: isHorizontal ? direction === "LR" ? "left" : "right" : direction === "TB" ? "top" : "bottom"
+    });
+  });
+  return { nodes: result, edges, controllerPositions };
+}
+
+// src/graph/graphControllers.ts
+var MAX_VISIBLE_CONTROLLER_CHILDREN = 5;
+function getDescendants(controllerId, containmentTree, controllerNodeIds) {
+  const result = /* @__PURE__ */ new Set();
+  const stack = [controllerId];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    for (const childId of containmentTree[id] || []) {
+      result.add(childId);
+      if (controllerNodeIds.has(childId)) stack.push(childId);
+    }
+  }
+  return result;
+}
+function buildControllerNodes(graphspec, analysis, layoutedNodes, controllerPositions) {
+  var _a;
+  const nodeById = {};
+  for (const n of layoutedNodes) {
+    nodeById[n.id] = n;
+  }
+  const controllerInfo = {};
+  for (const node of graphspec.nodes) {
+    if (analysis.controllerNodeIds.has(node.id)) {
+      controllerInfo[node.id] = node;
+    }
+  }
+  const depthCache = {};
+  const depthVisiting = /* @__PURE__ */ new Set();
+  function getDepth(controllerId) {
+    if (depthCache[controllerId] !== void 0) return depthCache[controllerId];
+    if (depthVisiting.has(controllerId)) {
+      throw new Error(
+        `Cycle detected in containment tree: controller "${controllerId}" is part of a containment cycle`
+      );
+    }
+    depthVisiting.add(controllerId);
+    const children = analysis.containmentTree[controllerId] || [];
+    let maxChildDepth = -1;
+    for (const childId of children) {
+      if (analysis.controllerNodeIds.has(childId)) {
+        maxChildDepth = Math.max(maxChildDepth, getDepth(childId));
+      }
+    }
+    depthVisiting.delete(controllerId);
+    depthCache[controllerId] = maxChildDepth + 1;
+    return depthCache[controllerId];
+  }
+  const childToController = buildChildToControllerMap(graphspec, analysis);
+  const controllerStuffChildren = {};
+  for (const [nodeId, ctrlId] of Object.entries(childToController)) {
+    if (!isStuffNodeId(nodeId)) continue;
+    if (!nodeById[nodeId]) continue;
+    if (!controllerStuffChildren[ctrlId]) controllerStuffChildren[ctrlId] = [];
+    controllerStuffChildren[ctrlId].push(nodeId);
+  }
+  const controllerIds = Array.from(analysis.controllerNodeIds);
+  for (const id of controllerIds) getDepth(id);
+  controllerIds.sort((a, b) => depthCache[a] - depthCache[b]);
+  const controllerNodes = [];
+  const childToParent = {};
+  for (const controllerId of controllerIds) {
+    const directChildren = analysis.containmentTree[controllerId] || [];
+    const renderedChildren = directChildren.filter((cid) => nodeById[cid]);
+    const stuffChildren = controllerStuffChildren[controllerId] || [];
+    const allChildren = [...renderedChildren, ...stuffChildren];
+    if (allChildren.length === 0) continue;
+    let groupX, groupY, groupW, groupH;
+    const elkPos = controllerPositions == null ? void 0 : controllerPositions[controllerId];
+    if (elkPos) {
+      groupX = elkPos.x;
+      groupY = elkPos.y;
+      groupW = elkPos.width;
+      groupH = elkPos.height;
+    } else {
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      for (const childId of allChildren) {
+        const child = nodeById[childId];
+        const pos = child.position;
+        const w = nodeWidth(child);
+        const h = nodeHeight(child);
+        minX = Math.min(minX, pos.x);
+        minY = Math.min(minY, pos.y);
+        maxX = Math.max(maxX, pos.x + w);
+        maxY = Math.max(maxY, pos.y + h);
+      }
+      const depth = (_a = depthCache[controllerId]) != null ? _a : 0;
+      const depthScale = 1 + depth * 0.15;
+      const padX = Math.round(CONTROLLER_PADDING_X * depthScale);
+      const padTop = Math.round(CONTROLLER_PADDING_TOP * depthScale);
+      const padBottom = Math.round(CONTROLLER_PADDING_BOTTOM * depthScale);
+      groupX = minX - padX;
+      groupY = minY - padTop;
+      groupW = maxX - minX + 2 * padX;
+      groupH = maxY - minY + padTop + padBottom;
+    }
+    const info = controllerInfo[controllerId] || {};
+    const pipeCode = info.pipe_code || controllerId.split(":").pop() || controllerId;
+    const groupNode = {
+      id: controllerId,
+      type: NODE_TYPE_CONTROLLER,
+      data: {
+        label: pipeCode,
+        pipeType: info.pipe_type,
+        isController: true,
+        isPipe: false,
+        isStuff: false,
+        pipeCode,
+        labelText: pipeCode
+      },
+      position: { x: groupX, y: groupY },
+      style: {
+        width: groupW + "px",
+        height: groupH + "px",
+        padding: "0"
+      }
+    };
+    controllerNodes.push(groupNode);
+    nodeById[controllerId] = groupNode;
+    for (const childId of allChildren) {
+      childToParent[childId] = controllerId;
+    }
+  }
+  for (const [childId, parentId] of Object.entries(childToParent)) {
+    const child = nodeById[childId];
+    const parent = nodeById[parentId];
+    if (!child || !parent) continue;
+    child.position = {
+      x: child.position.x - parent.position.x,
+      y: child.position.y - parent.position.y
+    };
+    child.parentId = parentId;
+    child.extent = "parent";
+  }
+  return controllerNodes;
+}
+function applyControllers(layoutedNodes, layoutedEdges, graphspec, analysis, showControllers, expandedControllers, onToggleCollapse, controllerPositions) {
+  var _a;
+  if (!showControllers || !analysis || !graphspec) {
+    return { nodes: layoutedNodes, edges: layoutedEdges };
+  }
+  const childCounts = {};
+  const collapsedSet = /* @__PURE__ */ new Set();
+  const controllerTypeMap = {};
+  for (const node of graphspec.nodes) {
+    if (analysis.controllerNodeIds.has(node.id)) {
+      controllerTypeMap[node.id] = node.pipe_type || "";
+    }
+  }
+  for (const ctrlId of analysis.controllerNodeIds) {
+    const directChildren = analysis.containmentTree[ctrlId] || [];
+    childCounts[ctrlId] = directChildren.length;
+    const pipeType = controllerTypeMap[ctrlId] || "";
+    const isCollapsible = pipeType === "PipeParallel" || pipeType === "PipeBatch";
+    if (isCollapsible && directChildren.length > MAX_VISIBLE_CONTROLLER_CHILDREN && !(expandedControllers == null ? void 0 : expandedControllers.has(ctrlId))) {
+      collapsedSet.add(ctrlId);
+    }
+  }
+  let filteredNodes = layoutedNodes;
+  let filteredEdges = layoutedEdges;
+  if (collapsedSet.size > 0) {
+    const hiddenNodes = /* @__PURE__ */ new Set();
+    for (const ctrlId of collapsedSet) {
+      const directChildren = analysis.containmentTree[ctrlId] || [];
+      const toHide = directChildren.slice(MAX_VISIBLE_CONTROLLER_CHILDREN);
+      for (const childId of toHide) {
+        hiddenNodes.add(childId);
+        if (analysis.controllerNodeIds.has(childId)) {
+          for (const d of getDescendants(
+            childId,
+            analysis.containmentTree,
+            analysis.controllerNodeIds
+          )) {
+            hiddenNodes.add(d);
+          }
+        }
+      }
+    }
+    const childToCtrl = buildChildToControllerMap(graphspec, analysis);
+    for (const node of layoutedNodes) {
+      if (!isStuffNodeId(node.id) || hiddenNodes.has(node.id)) continue;
+      const ctrlId = childToCtrl[node.id];
+      if (!ctrlId || !collapsedSet.has(ctrlId) && !hiddenNodes.has(ctrlId)) continue;
+      const pipeEdges = layoutedEdges.filter((e) => {
+        if (e.source !== node.id && e.target !== node.id) return false;
+        const other = e.source === node.id ? e.target : e.source;
+        return !isStuffNodeId(other);
+      });
+      if (pipeEdges.length === 0 || pipeEdges.every((e) => {
+        const other = e.source === node.id ? e.target : e.source;
+        return hiddenNodes.has(other);
+      })) {
+        hiddenNodes.add(node.id);
+      }
+    }
+    filteredNodes = layoutedNodes.filter((n) => !hiddenNodes.has(n.id));
+    filteredEdges = layoutedEdges.filter(
+      (e) => !hiddenNodes.has(e.source) && !hiddenNodes.has(e.target)
+    );
+  }
+  const controllerNodes = buildControllerNodes(
+    graphspec,
+    analysis,
+    filteredNodes,
+    controllerPositions
+  );
+  if (controllerNodes.length === 0) {
+    return { nodes: filteredNodes, edges: filteredEdges };
+  }
+  for (const cn of controllerNodes) {
+    const count = (_a = childCounts[cn.id]) != null ? _a : 0;
+    const isCollapsed = collapsedSet.has(cn.id);
+    cn.data.childCount = count;
+    cn.data.isCollapsed = isCollapsed;
+    if (onToggleCollapse) {
+      const id = cn.id;
+      cn.data.onToggleCollapse = () => onToggleCollapse(id);
+    }
+  }
+  const allNodes = [...controllerNodes, ...filteredNodes];
+  const nodeMap = {};
+  for (const n of allNodes) nodeMap[n.id] = n;
+  const depthOf = {};
+  const depthVisiting = /* @__PURE__ */ new Set();
+  function getContainmentDepth(id) {
+    if (depthOf[id] !== void 0) return depthOf[id];
+    if (depthVisiting.has(id)) {
+      throw new Error(
+        `Cycle detected in node parent chain: node "${id}" references itself as an ancestor`
+      );
+    }
+    depthVisiting.add(id);
+    const n = nodeMap[id];
+    depthOf[id] = n && n.parentId ? 1 + getContainmentDepth(n.parentId) : 0;
+    depthVisiting.delete(id);
+    return depthOf[id];
+  }
+  for (const n of allNodes) getContainmentDepth(n.id);
+  allNodes.sort((a, b) => depthOf[a.id] - depthOf[b.id]);
+  return { nodes: allNodes, edges: filteredEdges };
+}
+
+// src/graph/graphConfig.ts
+var DEFAULT_GRAPH_CONFIG = {
+  direction: "LR",
+  showControllers: false,
+  nodesep: 50,
+  ranksep: 100,
+  edgeType: EDGE_TYPE.DEFAULT,
+  initialZoom: null,
+  panToTop: true,
+  paletteColors: {
+    // Graph node/edge colors
+    "--color-pipe": "#ff6b6b",
+    "--color-pipe-bg": "rgba(224,108,117,0.18)",
+    "--color-pipe-text": "#ffffff",
+    "--color-stuff": "#4ECDC4",
+    "--color-stuff-bg": "rgba(78,205,196,0.12)",
+    "--color-stuff-border": "#9ddcfd",
+    "--color-stuff-text": "#98FB98",
+    "--color-stuff-text-dim": "#9ddcfd",
+    "--color-edge": "#FFFACD",
+    "--color-batch-item": "#bd93f9",
+    "--color-batch-aggregate": "#50fa7b",
+    "--color-parallel-combine": "#d6a4ff",
+    "--color-success": "#50FA7B",
+    "--color-success-bg": "rgba(80,250,123,0.15)",
+    "--color-error": "#FF5555",
+    "--color-error-bg": "rgba(255,85,85,0.15)",
+    "--color-accent": "#8BE9FD",
+    "--color-warning": "#FFB86C",
+    // Base theme vars used by graph-core.css
+    "--color-bg": "#0a0a0a",
+    "--color-bg-dots": "rgba(255, 255, 255, 0.35)",
+    "--color-text-muted": "#94a3b8",
+    "--color-controller-text": "#94a3b8",
+    "--font-sans": '"Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif',
+    "--font-mono": '"JetBrains Mono", "Monaco", "Menlo", monospace',
+    "--shadow-lg": "0 8px 24px rgba(0, 0, 0, 0.5)"
+  }
+};
+function getPaletteColors() {
+  return DEFAULT_GRAPH_CONFIG.paletteColors || {};
+}
+
+export {
+  NODE_TYPE_PIPE_CARD,
+  NODE_TYPE_STUFF,
+  NODE_TYPE_CONTROLLER,
+  STUFF_ID_PREFIX,
+  stuffNodeId,
+  isStuffNodeId,
+  stuffDigestFromId,
+  GRAPH_DIRECTION,
+  EDGE_TYPE,
+  CONTROLLER_PADDING_X,
+  CONTROLLER_PADDING_TOP,
+  CONTROLLER_PADDING_BOTTOM,
+  ARROW_CLOSED_MARKER,
+  nodeWidth,
+  nodeHeight,
+  buildDataflowAnalysis,
+  buildChildToControllerMap,
+  getPipeBlueprint,
+  getConceptInfo,
+  resolveConceptRef,
+  buildDataflowGraph,
+  buildGraph,
+  inputPortId,
+  outputPortId,
+  estimateNodeDimensions,
+  buildElkGraph,
+  extractAbsolutePositions,
+  getLayoutedElements,
+  MAX_VISIBLE_CONTROLLER_CHILDREN,
+  buildControllerNodes,
+  applyControllers,
+  DEFAULT_GRAPH_CONFIG,
+  getPaletteColors
+};
+//# sourceMappingURL=chunk-CCUSQM3E.js.map