diagram-contracts 0.1.0

package/dist/index.mjs

@@ -0,0 +1,4970 @@
+// src/schema/index.ts
+var TOKEN_CATALOG = {
+  widthSize: ["wrap", "fill"],
+  heightSize: ["wrap", "fill"],
+  align: ["start", "center", "end", "stretch"],
+  justify: ["start", "center", "end", "spaceBetween", "spaceAround", "spaceEvenly"],
+  contentAlign: [
+    "topStart",
+    "top",
+    "topEnd",
+    "start",
+    "center",
+    "end",
+    "bottomStart",
+    "bottom",
+    "bottomEnd"
+  ],
+  axis: ["vertical", "horizontal"],
+  // diagram-contracts specific
+  shape: [
+    "rect",
+    "roundedRect",
+    "circle",
+    "ellipse",
+    "diamond",
+    "parallelogram",
+    "capsule",
+    "cylinder",
+    "hexagon",
+    "triangle"
+  ],
+  anchorPosition: [
+    "topLeft",
+    "top",
+    "topRight",
+    "left",
+    "center",
+    "right",
+    "bottomLeft",
+    "bottom",
+    "bottomRight",
+    "auto"
+  ],
+  routeStyle: ["orthogonal", "straight", "curved"],
+  arrowHead: ["none", "arrow", "filledArrow", "diamond", "filledDiamond", "circle", "filledCircle"],
+  strokeStyle: ["solid", "dashed", "dotted"],
+  constraintStrength: ["required", "strong", "normal", "weak"],
+  textPosition: ["inside", "above", "below", "start", "end"],
+  textOverflow: ["clip", "ellipsis"],
+  fontWeight: ["regular", "medium", "bold"],
+  imageFit: ["contain", "cover", "fill", "none"],
+  cellHAlign: ["left", "center", "right"],
+  cellVAlign: ["top", "center", "bottom"],
+  geometryRole: ["layout", "align", "connect", "hit", "measure"],
+  geometryTarget: ["self", "icon"]
+};
+var PROPERTY_CATALOG = {
+  // ── identity ──────────────────────────────────────────────────────────
+  id: { type: "string", category: "identity", description: "Stable identifier for node/group. Used by constraints, diff, diagnostics" },
+  // ── size ──────────────────────────────────────────────────────────────
+  width: { type: "string | number", category: "size", description: "wrap / fill / fixed value" },
+  height: { type: "string | number", category: "size", description: "wrap / fill / fixed value" },
+  minWidth: { type: "number", category: "size" },
+  maxWidth: { type: "number | string", category: "size", notes: "fill allowed" },
+  minHeight: { type: "number", category: "size" },
+  maxHeight: { type: "number | string", category: "size", notes: "fill allowed" },
+  aspectRatio: { type: "number", category: "size", description: "width / height ratio" },
+  weight: { type: "number", category: "size", description: "Flex ratio in HStack / VStack" },
+  // ── spacing ───────────────────────────────────────────────────────────
+  padding: { type: "string | number", category: "spacing", description: "Inner padding. Token or per-side" },
+  gap: { type: "string | number", category: "spacing", description: "Gap between children" },
+  // ── alignment ─────────────────────────────────────────────────────────
+  align: { type: "string", category: "alignment", enum: "align", description: "Cross-axis alignment" },
+  justify: { type: "string", category: "alignment", enum: "justify", description: "Main-axis alignment" },
+  selfAlign: { type: "string", category: "alignment", enum: "align", description: "Self alignment override" },
+  contentAlign: { type: "string", category: "alignment", enum: "contentAlign", description: "Child content alignment (Box / Overlay)" },
+  axis: { type: "string", category: "alignment", enum: "axis", description: "Orientation axis" },
+  // ── visual ────────────────────────────────────────────────────────────
+  background: { type: "string", category: "visual", description: "Container background color token" },
+  foreground: { type: "string", category: "visual", description: "Foreground color token (text / icon propagation)" },
+  opacity: { type: "number", category: "visual", description: "Opacity 0..1" },
+  variant: { type: "string", category: "visual", description: "Theme variant" },
+  visible: { type: "boolean", category: "visual", description: "Visibility" },
+  // ── shape-visual ──────────────────────────────────────────────────────
+  shape: { type: "string", category: "shape-visual", lowering: "attribute", enum: "shape", description: "Visual shape. Layout always uses bounding rect" },
+  radius: { type: "string | number", category: "shape-visual", description: "Corner radius. Effective with shape: rect / roundedRect" },
+  fill: { type: "string", category: "shape-visual", lowering: "attribute", notes: "color token" },
+  stroke: { type: "string", category: "shape-visual", lowering: "attribute", notes: "color token" },
+  strokeWidth: { type: "number", category: "shape-visual", lowering: "attribute" },
+  strokeStyle: { type: "string", category: "shape-visual", lowering: "attribute", enum: "strokeStyle" },
+  shadow: { type: "string", category: "shape-visual", description: "Shadow token" },
+  // ── text ──────────────────────────────────────────────────────────────
+  text: { type: "string", category: "text", description: "Text content (normalized from child text nodes in IR)" },
+  textStyle: { type: "string", category: "text", description: "Typography token" },
+  textAlign: { type: "string", category: "text", description: "Text alignment (start / center / end)" },
+  fontSize: { type: "string | number", category: "text", description: "Font size" },
+  fontWeight: { type: "string", category: "text", enum: "fontWeight" },
+  lineLimit: { type: "number | string", category: "text", description: "Max lines. 'none' for unlimited" },
+  textOverflow: { type: "string", category: "text", enum: "textOverflow" },
+  textPosition: { type: "string", category: "text", lowering: "attribute", enum: "textPosition", description: "Label position on connector" },
+  // ── geometry ─────────────────────────────────────────────────────────
+  geometry: { type: "object", category: "geometry", description: "Geometry role mapping: { layout, align, connect, hit, measure } \u2192 target (self | icon | child id)" },
+  anchor: { type: "string", category: "constraint", lowering: "none", description: "Reference target for alignment; other targets become movers" },
+  // ── connector ─────────────────────────────────────────────────────────
+  from: { type: "string", category: "connector", lowering: "attribute", description: "Source node id or nodeId:role reference" },
+  to: { type: "string", category: "connector", lowering: "attribute", description: "Target node id or nodeId:role reference" },
+  fromAnchor: { type: "string", category: "connector", lowering: "attribute", enum: "anchorPosition" },
+  toAnchor: { type: "string", category: "connector", lowering: "attribute", enum: "anchorPosition" },
+  route: { type: "string", category: "connector", lowering: "attribute", enum: "routeStyle" },
+  cornerRadius: { type: "number", category: "connector", lowering: "attribute", description: "Corner rounding for orthogonal routing" },
+  curvature: { type: "number", category: "connector", lowering: "attribute", description: "Control point distance ratio for curved routing (0.1..1.0, default 0.33)" },
+  startArrow: { type: "string", category: "connector", lowering: "attribute", enum: "arrowHead" },
+  endArrow: { type: "string", category: "connector", lowering: "attribute", enum: "arrowHead" },
+  arrowSize: { type: "number", category: "connector", lowering: "attribute", description: "Arrow marker scale factor (default 1)" },
+  strokeDasharray: { type: "string", category: "shape-visual", lowering: "attribute", description: "Custom SVG stroke-dasharray. Overrides strokeStyle" },
+  // ── constraint ────────────────────────────────────────────────────────
+  targets: { type: "array", category: "constraint", lowering: "none", notes: "array<string>. Supports nodeId:role syntax for geometry role references" },
+  mover: { type: "string", category: "constraint", lowering: "none" },
+  strength: { type: "string", category: "constraint", lowering: "none", enum: "constraintStrength" },
+  strategy: { type: "string", category: "constraint", lowering: "none", description: "Size equalization strategy: max | min | first" },
+  // ── table ─────────────────────────────────────────────────────────────
+  colAlign: { type: "string", category: "alignment", enum: "cellHAlign", description: "Cell horizontal alignment (left / center / right)" },
+  rowAlign: { type: "string", category: "alignment", enum: "cellVAlign", description: "Cell vertical alignment (top / center / bottom)" },
+  headerRows: { type: "number", category: "structure", description: "Number of header rows (visual distinction)" },
+  // ── asset ─────────────────────────────────────────────────────────────
+  src: { type: "string", category: "asset", description: "Image / SVG source reference" },
+  fit: { type: "string", category: "asset", enum: "imageFit", description: "Fit method" },
+  name: { type: "string", category: "asset", lowering: "attribute", description: "Icon token or asset name" }
+};
+var ELEMENT_CATALOG = {
+  // ── structure ─────────────────────────────────────────────────────────
+  document: {
+    tier: "core",
+    category: "structure",
+    properties: ["id", "width", "height", "padding", "background", "variant"],
+    children: {
+      kind: "list",
+      items: [
+        "hstack",
+        "vstack",
+        "overlay",
+        "grid",
+        "flow",
+        "absolute",
+        "box",
+        "group",
+        "table",
+        "connector",
+        "alignConstraint",
+        "equalizeWidth",
+        "equalizeHeight",
+        "minGap",
+        "keepInsideConstraint",
+        "orderConstraint"
+      ]
+    }
+  },
+  group: {
+    tier: "core",
+    category: "structure",
+    properties: ["id", "visible", "padding", "gap", "background", "opacity", "geometry", "variant"],
+    children: { kind: "any" }
+  },
+  // ── layout ────────────────────────────────────────────────────────────
+  box: {
+    tier: "core",
+    category: "layout",
+    properties: [
+      "id",
+      "visible",
+      "width",
+      "height",
+      "minWidth",
+      "maxWidth",
+      "minHeight",
+      "maxHeight",
+      "padding",
+      "gap",
+      "contentAlign",
+      "foreground",
+      "fill",
+      "stroke",
+      "strokeWidth",
+      "strokeStyle",
+      "radius",
+      "shadow",
+      "opacity",
+      "shape",
+      "selfAlign",
+      "geometry",
+      "variant"
+    ],
+    children: { kind: "any" }
+  },
+  hstack: {
+    tier: "core",
+    category: "layout",
+    properties: [
+      "id",
+      "visible",
+      "gap",
+      "align",
+      "justify",
+      "padding",
+      "width",
+      "height",
+      "minWidth",
+      "maxWidth",
+      "minHeight",
+      "maxHeight",
+      "geometry",
+      "variant"
+    ],
+    children: { kind: "any" }
+  },
+  vstack: {
+    tier: "core",
+    category: "layout",
+    properties: [
+      "id",
+      "visible",
+      "gap",
+      "align",
+      "justify",
+      "padding",
+      "width",
+      "height",
+      "minWidth",
+      "maxWidth",
+      "minHeight",
+      "maxHeight",
+      "geometry",
+      "variant"
+    ],
+    children: { kind: "any" }
+  },
+  overlay: {
+    tier: "core",
+    category: "layout",
+    properties: ["id", "visible", "gap", "contentAlign", "padding", "width", "height", "background", "variant"],
+    children: { kind: "any" }
+  },
+  grid: {
+    tier: "core",
+    category: "layout",
+    properties: [
+      "id",
+      "visible",
+      "gap",
+      "align",
+      "justify",
+      "padding",
+      "width",
+      "height",
+      "minWidth",
+      "maxWidth",
+      "minHeight",
+      "maxHeight",
+      "variant"
+    ],
+    children: { kind: "any" },
+    notes: "Track definitions normalized as graph fragments. v1 starts with even tracks"
+  },
+  flow: {
+    tier: "core",
+    category: "layout",
+    properties: [
+      "id",
+      "visible",
+      "gap",
+      "padding",
+      "width",
+      "height",
+      "minWidth",
+      "maxWidth",
+      "align",
+      "variant"
+    ],
+    children: { kind: "any" }
+  },
+  absolute: {
+    tier: "optional",
+    category: "layout",
+    properties: ["id", "visible", "padding", "width", "height", "variant"],
+    children: { kind: "any" }
+  },
+  spacer: {
+    tier: "core",
+    category: "layout",
+    properties: ["id", "width", "height", "weight"],
+    children: { kind: "none" }
+  },
+  divider: {
+    tier: "core",
+    category: "layout",
+    properties: ["id", "axis", "stroke", "strokeWidth", "strokeStyle"],
+    children: { kind: "none" }
+  },
+  // ── text ──────────────────────────────────────────────────────────────
+  text: {
+    tier: "core",
+    category: "text",
+    properties: [
+      "id",
+      "text",
+      "visible",
+      "textStyle",
+      "textAlign",
+      "fontSize",
+      "fontWeight",
+      "lineLimit",
+      "textOverflow",
+      "foreground",
+      "background",
+      "opacity",
+      "padding",
+      "variant"
+    ],
+    children: { kind: "text" }
+  },
+  label: {
+    tier: "core",
+    category: "text",
+    properties: [
+      "id",
+      "text",
+      "visible",
+      "textStyle",
+      "textAlign",
+      "fontSize",
+      "fontWeight",
+      "textPosition",
+      "foreground",
+      "background",
+      "opacity",
+      "padding",
+      "radius",
+      "variant"
+    ],
+    children: { kind: "text" }
+  },
+  // ── media ─────────────────────────────────────────────────────────────
+  image: {
+    tier: "core",
+    category: "media",
+    properties: ["id", "visible", "src", "fit", "width", "height", "aspectRatio", "radius", "opacity", "variant"],
+    children: { kind: "none" }
+  },
+  icon: {
+    tier: "core",
+    category: "media",
+    properties: ["id", "visible", "name", "foreground", "opacity", "variant"],
+    children: { kind: "none" }
+  },
+  svgAsset: {
+    tier: "core",
+    category: "media",
+    properties: ["id", "visible", "src", "width", "height", "opacity", "variant"],
+    children: { kind: "none" }
+  },
+  // ── table ───────────────────────────────────────────────────────────
+  table: {
+    tier: "core",
+    category: "layout",
+    properties: [
+      "id",
+      "visible",
+      "width",
+      "height",
+      "padding",
+      "gap",
+      "headerRows",
+      "fill",
+      "stroke",
+      "strokeWidth",
+      "variant"
+    ],
+    children: { kind: "list", items: ["row"] },
+    notes: "Table layout. Column widths equalized via columnWidthResolve (max of cell intrinsic widths). Row heights equalized via rowHeightResolve. No special table algorithm."
+  },
+  row: {
+    tier: "core",
+    category: "layout",
+    properties: ["id", "visible", "fill", "variant"],
+    children: { kind: "list", items: ["cell"] }
+  },
+  cell: {
+    tier: "core",
+    category: "layout",
+    properties: [
+      "id",
+      "visible",
+      "width",
+      "height",
+      "padding",
+      "colAlign",
+      "rowAlign",
+      "fill",
+      "stroke",
+      "strokeWidth",
+      "foreground",
+      "variant"
+    ],
+    children: { kind: "any" },
+    notes: "Table cell. colAlign (left/center/right) and rowAlign (top/center/bottom) control content positioning within the cell"
+  },
+  // ── connector ─────────────────────────────────────────────────────────
+  connector: {
+    tier: "core",
+    category: "connector",
+    properties: [
+      "id",
+      "visible",
+      "from",
+      "to",
+      "fromAnchor",
+      "toAnchor",
+      "route",
+      "cornerRadius",
+      "curvature",
+      "startArrow",
+      "endArrow",
+      "arrowSize",
+      "stroke",
+      "strokeWidth",
+      "strokeStyle",
+      "strokeDasharray",
+      "opacity",
+      "variant"
+    ],
+    children: { kind: "list", items: ["label"] },
+    notes: "Child Labels are annotation text on the connector. Label.textPosition specifies position"
+  },
+  // ── constraint ────────────────────────────────────────────────────────
+  alignConstraint: {
+    tier: "core",
+    category: "constraint",
+    properties: ["id", "targets", "axis", "align", "anchor", "mover", "strength"],
+    children: { kind: "none" },
+    notes: "axis: vertical + align: center = centerX alignment. axis: horizontal + align: center = centerY alignment"
+  },
+  equalizeWidth: {
+    tier: "core",
+    category: "constraint",
+    properties: ["id", "targets", "strategy", "strength"],
+    children: { kind: "none" },
+    notes: "Equalize widths of all targets. strategy: max (default) | min | first"
+  },
+  equalizeHeight: {
+    tier: "core",
+    category: "constraint",
+    properties: ["id", "targets", "strategy", "strength"],
+    children: { kind: "none" },
+    notes: "Equalize heights of all targets. strategy: max (default) | min | first"
+  },
+  minGap: {
+    tier: "optional",
+    category: "constraint",
+    properties: ["id", "targets", "gap", "axis", "strength"],
+    children: { kind: "none" }
+  },
+  keepInsideConstraint: {
+    tier: "optional",
+    category: "constraint",
+    properties: ["id", "targets", "strength"],
+    children: { kind: "none" }
+  },
+  orderConstraint: {
+    tier: "core",
+    category: "constraint",
+    properties: ["id", "targets", "axis", "strength"],
+    children: { kind: "none" },
+    notes: "targets array order is source order. axis: vertical = top-to-bottom, horizontal = left-to-right"
+  }
+};
+
+// src/ir/index.ts
+import { z } from "zod";
+var IrNodeSchema = z.lazy(
+  () => z.object({
+    kind: z.string(),
+    id: z.string().optional(),
+    props: z.record(z.string(), z.unknown()),
+    children: z.array(IrNodeSchema).optional()
+  })
+);
+function buildValidPropsSet(kind) {
+  const element = ELEMENT_CATALOG[kind];
+  if (!element) return /* @__PURE__ */ new Set();
+  const props = new Set(element.properties);
+  if (element.children.kind === "text") {
+    props.add("text");
+  }
+  return props;
+}
+function validateNode(node, path) {
+  if (!(node.kind in ELEMENT_CATALOG)) {
+    throw new Error(`Invalid element kind '${node.kind}' at ${path}`);
+  }
+  const validProps = buildValidPropsSet(node.kind);
+  const unknownProps = Object.keys(node.props).filter((k) => !validProps.has(k));
+  if (unknownProps.length > 0) {
+    throw new Error(
+      `Unknown properties for '${node.kind}' at ${path}: ${unknownProps.join(", ")}`
+    );
+  }
+  if (node.children) {
+    for (let i = 0; i < node.children.length; i++) {
+      validateNode(node.children[i], `${path}.children[${i}]`);
+    }
+  }
+}
+function parseIr(json) {
+  const parsed = IrNodeSchema.parse(json);
+  validateNode(parsed, "root");
+  return parsed;
+}
+
+// src/parser/tokenizer.ts
+var SHAPE_PATTERNS = [
+  { shape: "capsule", open: "([", close: "])" },
+  { shape: "cylinder", open: "[(", close: ")]" },
+  { shape: "circle", open: "((", close: "))" },
+  { shape: "hexagon", open: "[[", close: "]]" },
+  { shape: "roundedRect", open: "[", close: "]" },
+  { shape: "diamond", open: "{", close: "}" },
+  { shape: "rect", open: "(", close: ")" }
+];
+function parseNodeShape(rest) {
+  let shapeOverride;
+  let cursor = 0;
+  if (rest.startsWith("@")) {
+    const atMatch = rest.match(/^@(\w+)/);
+    if (!atMatch) return null;
+    shapeOverride = atMatch[1];
+    cursor = atMatch[0].length;
+  }
+  const remaining = rest.slice(cursor);
+  for (const { shape, open, close } of SHAPE_PATTERNS) {
+    if (!remaining.startsWith(open)) continue;
+    const contentStart = open.length;
+    const closeIdx = remaining.indexOf(close, contentStart);
+    if (closeIdx === -1) continue;
+    const afterClose = remaining.slice(closeIdx + close.length);
+    if (afterClose.length > 0 && /^[a-zA-Z0-9_-]/.test(afterClose)) continue;
+    let label = remaining.slice(contentStart, closeIdx);
+    if (label.startsWith('"') && label.endsWith('"')) {
+      label = label.slice(1, -1);
+    }
+    return {
+      label,
+      shape: shapeOverride ?? shape,
+      shapeOverride,
+      consumed: cursor + closeIdx + close.length
+    };
+  }
+  return null;
+}
+function matchEdgeOp(s) {
+  const trimmed = s.trimStart();
+  for (const op of ["==>", "-.->", "-->", "---", "~~~"]) {
+    if (!trimmed.startsWith(op)) continue;
+    let after = trimmed.slice(op.length);
+    let label;
+    if (op !== "~~~" && after.startsWith("|")) {
+      const pipeEnd = after.indexOf("|", 1);
+      if (pipeEnd !== -1) {
+        label = after.slice(1, pipeEnd).trim();
+        after = after.slice(pipeEnd + 1);
+      }
+    }
+    return { op, label, rest: after };
+  }
+  return null;
+}
+function parseNodeRef(s) {
+  const trimmed = s.trimStart();
+  const idMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/);
+  if (!idMatch) return null;
+  const nodeId = idMatch[1];
+  let after = trimmed.slice(idMatch[0].length);
+  const shapeParsed = parseNodeShape(after);
+  let def;
+  if (shapeParsed) {
+    after = after.slice(shapeParsed.consumed);
+    def = { label: shapeParsed.label, shape: shapeParsed.shape, shapeOverride: shapeParsed.shapeOverride };
+  }
+  if (after.startsWith(":::")) {
+    const classMatch = after.slice(3).match(/^([a-zA-Z_][a-zA-Z0-9_-]*)/);
+    if (classMatch) {
+      if (def) {
+        def.variant = classMatch[1];
+      } else {
+        def = { label: nodeId, shape: "roundedRect", variant: classMatch[1] };
+      }
+      after = after.slice(3 + classMatch[0].length);
+    }
+  }
+  return { nodeId, def, rest: after };
+}
+function tokenizeLine(line, lineNum) {
+  const trimmed = line.trim();
+  if (trimmed === "") return null;
+  if (trimmed.startsWith("%%")) {
+    return { type: "comment", raw: line, line: lineNum };
+  }
+  const dirMatch = trimmed.match(/^(?:flowchart|graph)\s+(TD|TB|LR)$/i);
+  if (dirMatch) {
+    const dirRaw = dirMatch[1].toUpperCase();
+    const dir = dirRaw === "TB" ? "TD" : dirRaw;
+    if (dir !== "TD" && dir !== "LR") {
+      return null;
+    }
+    return { type: "direction", raw: line, line: lineNum, dir };
+  }
+  const subMatch = trimmed.match(/^subgraph\s+(\S+)(?:\s+\[([^\]]*)\])?\s*$/);
+  if (subMatch) {
+    return {
+      type: "subgraphStart",
+      raw: line,
+      line: lineNum,
+      subgraphId: subMatch[1],
+      label: subMatch[2] ?? void 0
+    };
+  }
+  if (trimmed === "end") {
+    return { type: "subgraphEnd", raw: line, line: lineNum };
+  }
+  const localDirMatch = trimmed.match(/^direction\s+(TD|TB|LR)$/i);
+  if (localDirMatch) {
+    const dirRaw = localDirMatch[1].toUpperCase();
+    const dir = dirRaw === "TB" ? "TD" : dirRaw;
+    return { type: "localDirection", raw: line, line: lineNum, dir };
+  }
+  const classDefMatch = trimmed.match(/^classDef\s+(\S+)\s+(.+)$/);
+  if (classDefMatch) {
+    return {
+      type: "classDef",
+      raw: line,
+      line: lineNum,
+      className: classDefMatch[1],
+      styles: classDefMatch[2]
+    };
+  }
+  if (trimmed.startsWith("@")) {
+    return parseDirective(trimmed, line, lineNum);
+  }
+  return parseEdgeOrNodeLine(trimmed, line, lineNum);
+}
+function parseDirective(trimmed, raw, lineNum) {
+  const sameWidthMatch = trimmed.match(/^@same-width(?:\s+(\w+))?:\s*(.+)$/);
+  if (sameWidthMatch) {
+    const strategy = sameWidthMatch[1] ?? "max";
+    const targets = sameWidthMatch[2].split(",").map((t) => t.trim()).filter(Boolean);
+    return {
+      type: "directive",
+      raw,
+      line: lineNum,
+      directiveType: "same-width",
+      strategy,
+      targets
+    };
+  }
+  const sameHeightMatch = trimmed.match(/^@same-height(?:\s+(\w+))?:\s*(.+)$/);
+  if (sameHeightMatch) {
+    const strategy = sameHeightMatch[1] ?? "max";
+    const targets = sameHeightMatch[2].split(",").map((t) => t.trim()).filter(Boolean);
+    return {
+      type: "directive",
+      raw,
+      line: lineNum,
+      directiveType: "same-height",
+      strategy,
+      targets
+    };
+  }
+  const gapMatch = trimmed.match(/^@gap\s+min=(\d+):\s*(.+)$/);
+  if (gapMatch) {
+    const min = parseInt(gapMatch[1], 10);
+    const targets = gapMatch[2].split(",").map((t) => t.trim()).filter(Boolean);
+    return {
+      type: "directive",
+      raw,
+      line: lineNum,
+      directiveType: "gap",
+      min,
+      targets
+    };
+  }
+  const moverMatch = trimmed.match(/^@mover\s+(\S+):\s*(.+)$/);
+  if (moverMatch) {
+    const moverId = moverMatch[1];
+    const targets = moverMatch[2].split(",").map((t) => t.trim()).filter(Boolean);
+    return {
+      type: "directive",
+      raw,
+      line: lineNum,
+      directiveType: "mover",
+      moverId,
+      targets
+    };
+  }
+  return null;
+}
+function parseEdgeOrNodeLine(trimmed, raw, lineNum) {
+  const firstRef = parseNodeRef(trimmed);
+  if (!firstRef) return null;
+  let cursor = trimmed.length - firstRef.rest.length;
+  let remaining = firstRef.rest;
+  const edgeMatch = matchEdgeOp(remaining);
+  if (!edgeMatch) {
+    if (!firstRef.def) {
+      return null;
+    }
+    return {
+      type: "nodeDef",
+      raw,
+      line: lineNum,
+      nodeId: firstRef.nodeId,
+      label: firstRef.def.label,
+      shape: firstRef.def.shape,
+      variant: firstRef.def.variant,
+      shapeOverride: firstRef.def.shapeOverride
+    };
+  }
+  if (edgeMatch.op === "~~~") {
+    return parseInvisibleEdgeChain(trimmed, firstRef, raw, lineNum);
+  }
+  return parseVisibleEdgeChain(trimmed, firstRef, raw, lineNum);
+}
+function parseInvisibleEdgeChain(input, firstRef, raw, lineNum) {
+  const segments = [];
+  let currentId = firstRef.nodeId;
+  let remaining = firstRef.rest;
+  while (true) {
+    const edgeMatch = matchEdgeOp(remaining);
+    if (!edgeMatch || edgeMatch.op !== "~~~") break;
+    remaining = edgeMatch.rest;
+    const nextRef = parseNodeRef(remaining);
+    if (!nextRef) break;
+    segments.push({ fromId: currentId, toId: nextRef.nodeId });
+    currentId = nextRef.nodeId;
+    remaining = nextRef.rest;
+  }
+  return { type: "invisibleEdge", raw, line: lineNum, segments };
+}
+function parseVisibleEdgeChain(input, firstRef, raw, lineNum) {
+  const segments = [];
+  let currentId = firstRef.nodeId;
+  let currentDef = firstRef.def;
+  let remaining = firstRef.rest;
+  while (true) {
+    const edgeMatch = matchEdgeOp(remaining);
+    if (!edgeMatch || edgeMatch.op === "~~~") break;
+    remaining = edgeMatch.rest;
+    let colonLabel;
+    const nextRef = parseNodeRef(remaining);
+    if (!nextRef) break;
+    remaining = nextRef.rest;
+    const colonMatch = remaining.match(/^\s*:\s*(.+?)$/);
+    if (colonMatch) {
+      colonLabel = colonMatch[1].trim();
+      remaining = "";
+    }
+    const seg = {
+      fromId: currentId,
+      toId: nextRef.nodeId,
+      edgeType: edgeMatch.op,
+      edgeLabel: edgeMatch.label ?? colonLabel
+    };
+    if (currentDef) {
+      seg.fromDef = currentDef;
+    }
+    if (nextRef.def) {
+      seg.toDef = nextRef.def;
+    }
+    segments.push(seg);
+    currentId = nextRef.nodeId;
+    currentDef = nextRef.def;
+  }
+  return { type: "edge", raw, line: lineNum, segments };
+}
+function tokenize(source) {
+  const lines = source.split("\n");
+  const tokens = [];
+  for (let i = 0; i < lines.length; i++) {
+    const token = tokenizeLine(lines[i], i + 1);
+    if (token) {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+}
+
+// src/parser/parser.ts
+function parseDrawText(source) {
+  const diagnostics = [];
+  const tokens = tokenize(source);
+  let rootDirection = "TD";
+  const nodeMap = /* @__PURE__ */ new Map();
+  const connectors = [];
+  const constraints = [];
+  const classDefMap = /* @__PURE__ */ new Map();
+  const scopeStack = [];
+  const groups = [];
+  const rootNodeIds = [];
+  function currentDirection() {
+    for (let i = scopeStack.length - 1; i >= 0; i--) {
+      if (scopeStack[i].direction) return scopeStack[i].direction;
+    }
+    return rootDirection;
+  }
+  function registerNode(id, label, shape, variant) {
+    if (!nodeMap.has(id)) {
+      nodeMap.set(id, { id, label, shape, variant });
+    }
+    if (scopeStack.length > 0) {
+      const top = scopeStack[scopeStack.length - 1];
+      if (!top.nodeIds.includes(id)) top.nodeIds.push(id);
+    } else {
+      if (!rootNodeIds.includes(id)) rootNodeIds.push(id);
+    }
+  }
+  function ensureNode(id) {
+    if (nodeMap.has(id)) return;
+    nodeMap.set(id, { id, label: id, shape: "roundedRect" });
+    if (scopeStack.length > 0) {
+      const top = scopeStack[scopeStack.length - 1];
+      if (!top.nodeIds.includes(id)) top.nodeIds.push(id);
+    } else {
+      if (!rootNodeIds.includes(id)) rootNodeIds.push(id);
+    }
+  }
+  for (const token of tokens) {
+    switch (token.type) {
+      case "comment":
+        break;
+      case "direction":
+        rootDirection = token.dir;
+        break;
+      case "nodeDef": {
+        const t = token;
+        registerNode(t.nodeId, t.label, t.shape, t.variant);
+        break;
+      }
+      case "edge": {
+        const t = token;
+        for (const seg of t.segments) {
+          processEdgeSegment(seg);
+        }
+        break;
+      }
+      case "invisibleEdge": {
+        const t = token;
+        for (const seg of t.segments) {
+          ensureNode(seg.fromId);
+          ensureNode(seg.toId);
+        }
+        const dir = currentDirection();
+        const allIds = /* @__PURE__ */ new Set();
+        for (const seg of t.segments) {
+          allIds.add(seg.fromId);
+          allIds.add(seg.toId);
+        }
+        constraints.push(buildAlignConstraint([...allIds], dir));
+        break;
+      }
+      case "subgraphStart": {
+        const t = token;
+        scopeStack.push({
+          id: t.subgraphId,
+          label: t.label,
+          nodeIds: []
+        });
+        break;
+      }
+      case "subgraphEnd": {
+        if (scopeStack.length === 0) {
+          diagnostics.push({
+            level: "warning",
+            message: "Unexpected 'end' without matching subgraph",
+            path: `line:${token.line}`
+          });
+          break;
+        }
+        const frame = scopeStack.pop();
+        groups.push({ frame, children: [...frame.nodeIds] });
+        if (scopeStack.length > 0) {
+          const parent = scopeStack[scopeStack.length - 1];
+          if (!parent.nodeIds.includes(frame.id)) parent.nodeIds.push(frame.id);
+        } else {
+          if (!rootNodeIds.includes(frame.id)) rootNodeIds.push(frame.id);
+        }
+        break;
+      }
+      case "localDirection": {
+        const t = token;
+        if (scopeStack.length > 0) {
+          scopeStack[scopeStack.length - 1].direction = t.dir;
+        } else {
+          rootDirection = t.dir;
+        }
+        break;
+      }
+      case "classDef": {
+        const t = token;
+        classDefMap.set(t.className, t.styles);
+        break;
+      }
+      case "directive": {
+        const t = token;
+        processDirective(t);
+        break;
+      }
+    }
+  }
+  function processEdgeSegment(seg) {
+    if (seg.fromDef) {
+      registerNode(seg.fromId, seg.fromDef.label, seg.fromDef.shape, seg.fromDef.variant);
+    } else {
+      ensureNode(seg.fromId);
+    }
+    if (seg.toDef) {
+      registerNode(seg.toId, seg.toDef.label, seg.toDef.shape, seg.toDef.variant);
+    } else {
+      ensureNode(seg.toId);
+    }
+    const connectorProps = {
+      from: seg.fromId,
+      to: seg.toId
+    };
+    switch (seg.edgeType) {
+      case "-->":
+        connectorProps.endArrow = "arrow";
+        break;
+      case "---":
+        connectorProps.startArrow = "none";
+        connectorProps.endArrow = "none";
+        break;
+      case "-.->":
+        connectorProps.strokeStyle = "dashed";
+        connectorProps.endArrow = "arrow";
+        break;
+      case "==>":
+        connectorProps.strokeWidth = 3;
+        connectorProps.endArrow = "arrow";
+        break;
+    }
+    const children = [];
+    if (seg.edgeLabel) {
+      children.push({
+        kind: "label",
+        props: { text: seg.edgeLabel }
+      });
+    }
+    const connector = {
+      kind: "connector",
+      props: connectorProps
+    };
+    if (children.length > 0) {
+      connector.children = children;
+    }
+    connectors.push(connector);
+  }
+  function processDirective(t) {
+    switch (t.directiveType) {
+      case "same-width": {
+        const props = { targets: t.targets };
+        if (t.strategy) props.strategy = t.strategy;
+        constraints.push({ kind: "equalizeWidth", props });
+        break;
+      }
+      case "same-height": {
+        const props = { targets: t.targets };
+        if (t.strategy) props.strategy = t.strategy;
+        constraints.push({ kind: "equalizeHeight", props });
+        break;
+      }
+      case "gap": {
+        const props = {
+          targets: t.targets,
+          gap: t.min
+        };
+        constraints.push({ kind: "minGap", props });
+        break;
+      }
+      case "mover": {
+        const props = {
+          targets: t.targets,
+          mover: t.moverId
+        };
+        constraints.push({ kind: "alignConstraint", props });
+        break;
+      }
+    }
+  }
+  const stackKind = rootDirection === "LR" ? "hstack" : "vstack";
+  const groupNodes = /* @__PURE__ */ new Map();
+  for (const g of groups) {
+    const dir = g.frame.direction ?? rootDirection;
+    const innerKind = dir === "LR" ? "hstack" : "vstack";
+    const groupChildren = [];
+    const innerStack = {
+      kind: innerKind,
+      props: { gap: 60, align: "center" },
+      children: []
+    };
+    for (const childId of g.children) {
+      const childGroup = groupNodes.get(childId);
+      if (childGroup) {
+        innerStack.children.push(childGroup);
+      } else {
+        const node = nodeMap.get(childId);
+        if (node) {
+          innerStack.children.push(buildBox(node));
+        }
+      }
+    }
+    groupChildren.push(innerStack);
+    const groupNode = {
+      kind: "group",
+      id: g.frame.id,
+      props: {},
+      children: groupChildren
+    };
+    if (g.frame.label) {
+      groupNode.props.label = g.frame.label;
+    }
+    groupNodes.set(g.frame.id, groupNode);
+  }
+  const rootChildren = [];
+  for (const id of rootNodeIds) {
+    const groupNode = groupNodes.get(id);
+    if (groupNode) {
+      rootChildren.push(groupNode);
+    } else {
+      const node = nodeMap.get(id);
+      if (node) {
+        rootChildren.push(buildBox(node));
+      }
+    }
+  }
+  const rootStack = {
+    kind: stackKind,
+    props: { gap: 60, align: "center" },
+    children: rootChildren
+  };
+  const documentChildren = [rootStack, ...connectors, ...constraints];
+  const document = {
+    kind: "document",
+    props: { padding: 20 },
+    children: documentChildren
+  };
+  return { ir: document, diagnostics };
+}
+function buildBox(node) {
+  const props = { shape: node.shape };
+  if (node.variant) {
+    props.variant = node.variant;
+  }
+  return {
+    kind: "box",
+    id: node.id,
+    props,
+    children: [
+      { kind: "text", props: { text: node.label } }
+    ]
+  };
+}
+function buildAlignConstraint(targets, direction) {
+  const axis = direction === "TD" ? "vertical" : "horizontal";
+  return {
+    kind: "alignConstraint",
+    props: {
+      targets,
+      axis,
+      align: "center"
+    }
+  };
+}
+
+// src/compiler/compiler.ts
+import ts from "typescript";
+
+// src/graph/rule-engine.ts
+import { load } from "js-yaml";
+
+// src/graph/graph-helpers.ts
+function slotId(nodeId, kind) {
+  return `${nodeId}.${kind}`;
+}
+function ensureSlot(graph, nodeId, kind, value) {
+  const id = slotId(nodeId, kind);
+  let slot = graph.slots.get(id);
+  if (!slot) {
+    slot = { id, value, nodeId, slotKind: kind };
+    graph.slots.set(id, slot);
+  } else if (value !== void 0 && slot.value === void 0) {
+    slot.value = value;
+  }
+  return slot;
+}
+function addCandidate(graph, targetSlotId, value, source, priority, operationId) {
+  const candidate = { targetSlotId, value, source, priority, operationId };
+  graph.candidates.push(candidate);
+  let bySlot = graph.candidatesBySlot.get(targetSlotId);
+  if (!bySlot) {
+    bySlot = [];
+    graph.candidatesBySlot.set(targetSlotId, bySlot);
+  }
+  bySlot.push(candidate);
+  if (operationId) {
+    let byOp = graph.candidatesByOperation.get(operationId);
+    if (!byOp) {
+      byOp = [];
+      graph.candidatesByOperation.set(operationId, byOp);
+    }
+    byOp.push(candidate);
+  }
+  return candidate;
+}
+function addOperation(graph, id, op, inputs, outputs, compute) {
+  const operation = { id, op, inputs, outputs, compute };
+  graph.operations.set(id, operation);
+  for (const inputSlotId of inputs) {
+    graph.dependencies.push({ fromSlotId: inputSlotId, toOperationId: id });
+  }
+  return operation;
+}
+function addResolver(graph, targetSlotId, policy) {
+  if (!graph.resolvers.has(targetSlotId)) {
+    graph.resolvers.set(targetSlotId, { slotId: targetSlotId, policy });
+  }
+}
+function getNumericProp(node, prop, fallback) {
+  const val = node.props[prop];
+  if (typeof val === "number") return val;
+  if (typeof val === "string") {
+    const n = parseFloat(val);
+    if (!isNaN(n)) return n;
+  }
+  return fallback;
+}
+function getSizeProp(node, prop) {
+  const val = node.props[prop];
+  if (typeof val === "number") return val;
+  if (val === "wrap") return "wrap";
+  if (val === "fill") return "fill";
+  if (typeof val === "string") {
+    const n = parseFloat(val);
+    if (!isNaN(n)) return n;
+  }
+  return "wrap";
+}
+function isConstraintKind(kind) {
+  return kind === "alignConstraint" || kind === "equalizeWidth" || kind === "equalizeHeight" || kind === "minGap" || kind === "keepInsideConstraint" || kind === "orderConstraint";
+}
+function registerSizeSlots(node, graph, parentId) {
+  const id = node.id;
+  const widthIntent = getSizeProp(node, "width");
+  const heightIntent = getSizeProp(node, "height");
+  ensureSlot(graph, id, "resolvedWidth");
+  ensureSlot(graph, id, "resolvedHeight");
+  ensureSlot(graph, id, "localX");
+  ensureSlot(graph, id, "localY");
+  if (typeof widthIntent === "number") {
+    ensureSlot(graph, id, "contentWidth", widthIntent);
+    addCandidate(graph, slotId(id, "contentWidth"), widthIntent, `${node.kind}(${id}).explicit`, "required");
+    addCandidate(graph, slotId(id, "resolvedWidth"), widthIntent, `${node.kind}(${id}).explicit`, "normal");
+  } else if (widthIntent === "fill" && parentId) {
+    ensureSlot(graph, parentId, "availableWidth");
+  }
+  if (typeof heightIntent === "number") {
+    ensureSlot(graph, id, "contentHeight", heightIntent);
+    addCandidate(graph, slotId(id, "contentHeight"), heightIntent, `${node.kind}(${id}).explicit`, "required");
+    addCandidate(graph, slotId(id, "resolvedHeight"), heightIntent, `${node.kind}(${id}).explicit`, "normal");
+  } else if (heightIntent === "fill" && parentId) {
+    ensureSlot(graph, parentId, "availableHeight");
+  }
+}
+
+// src/graph/ops.ts
+function opSum(inputs) {
+  return [inputs.reduce((a, b) => a + b, 0)];
+}
+function opMax(inputs) {
+  if (inputs.length === 0) return [0];
+  return [Math.max(...inputs)];
+}
+function opClamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function opConstant(value) {
+  return () => [value];
+}
+var SimpleTextMeasurer = class {
+  measure(text, fontSize, maxWidth) {
+    const charWidth = 0.6 * fontSize;
+    const lineHeight = 1.4 * fontSize;
+    if (!text) {
+      return { width: 0, height: lineHeight, lines: [""] };
+    }
+    const lines = wrapLines(text, maxWidth, (t) => t.length * charWidth);
+    const width = Math.max(...lines.map((l) => l.length * charWidth));
+    const height = lines.length * lineHeight;
+    return { width, height, lines };
+  }
+};
+function wrapLines(text, maxWidth, measureFn) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  if (maxWidth !== void 0 && maxWidth > 0) {
+    let currentLine = "";
+    for (const word of words) {
+      const candidate = currentLine ? `${currentLine} ${word}` : word;
+      if (measureFn(candidate) > maxWidth && currentLine) {
+        lines.push(currentLine);
+        currentLine = word;
+      } else {
+        currentLine = candidate;
+      }
+    }
+    if (currentLine) lines.push(currentLine);
+  } else {
+    lines.push(text);
+  }
+  return lines;
+}
+
+// src/graph/rule-engine.ts
+var CONSTRAINT_RULES_YAML = `
+# Constraint Rules \u2014 declarative definition of constraint behavior
+#
+# No code here. Each constraint declares which slots it references, which slots
+# receive emitted candidates, and which operation computes values.
+#
+# rule-engine.ts reads this definition and generically generates graph primitives.
+
+alignConstraint:
+  operation: world_align
+  description: "Align movers to reference absolute coordinates (cross-container)"
+  axis_mapping:
+    horizontal:
+      world_slot: worldY
+      local_slot: localY
+      size_slot: resolvedHeight
+    vertical:
+      world_slot: worldX
+      local_slot: localX
+      size_slot: resolvedWidth
+  reference: "targets[0]"
+  movers: "mover ?? targets[1:]"
+  priority_from: strength
+  default_priority: required
+
+equalizeWidth:
+  operation: equalize
+  description: "Equalize width across all targets per strategy"
+  slot: resolvedWidth
+  content_slot: contentWidth
+  targets: "targets"
+  strategy_from: strategy
+  default_strategy: max
+  priority_from: strength
+  default_priority: strong
+
+equalizeHeight:
+  operation: equalize
+  description: "Equalize height across all targets per strategy"
+  slot: resolvedHeight
+  content_slot: contentHeight
+  targets: "targets"
+  strategy_from: strategy
+  default_strategy: max
+  priority_from: strength
+  default_priority: strong
+
+orderConstraint:
+  operation: enforce_order
+  description: "Emit candidates so slot values ascend in targets order"
+  axis_to_slot:
+    horizontal: localX
+    vertical: localY
+  axis_to_size_slot:
+    horizontal: resolvedWidth
+    vertical: resolvedHeight
+  targets: "targets"
+  priority_from: strength
+  default_priority: strong
+  resolver_policy: highestPriority
+
+minGap:
+  operation: enforce_min_gap
+  description: "Guarantee minimum gap between targets"
+  axis_to_position_slot:
+    horizontal: localX
+    vertical: localY
+  axis_to_size_slot:
+    horizontal: resolvedWidth
+    vertical: resolvedHeight
+  min_gap_from: gap
+  targets: "targets"
+  priority_from: strength
+  default_priority: strong
+  resolver_policy: highestPriority
+
+keepInsideConstraint:
+  operation: clamp_inside
+  description: "Clamp positions so contents stay inside container rect"
+  container: "targets[0]"
+  contents: "targets[1:]"
+  position_slots: [localX, localY]
+  size_slots: [resolvedWidth, resolvedHeight]
+  priority_from: strength
+  default_priority: strong
+  resolver_policy: highestPriority
+`;
+var LAYOUT_RULES_YAML = `
+# Layout Rules \u2014 graph fragment generation rules for layout elements
+#
+# Declaratively defines which slots each layout element generates and which
+# operations compute child position and size.
+#
+# The stack rule treats vstack/hstack uniformly via axis parameters.
+
+# ---------------------------------------------------------------------------
+# style_props \u2014 renderer-only properties (kind \u2192 props[])
+# Separate from layout params; the renderer reads these transparently as styles.
+# The compiler unions this list with layout params to detect unknown properties.
+# ---------------------------------------------------------------------------
+style_props:
+  _common: [variant, fill, stroke, strokeWidth, strokeStyle, strokeDasharray, opacity, radius, shape, foreground, fontFamily, background]
+  document: [fontFamily, background]
+  box: [fill, stroke, strokeWidth, strokeStyle, strokeDasharray, opacity, radius, shape]
+  text: [foreground, fontFamily]
+  label: [foreground, fontFamily]
+  connector: [stroke, strokeWidth, strokeStyle, strokeDasharray, opacity, from, to, fromAnchor, toAnchor, route, cornerRadius, startArrow, endArrow, arrowSize]
+  image: [src, fit]
+  icon: [name, foreground]
+  svgAsset: [src]
+  table: [borderRadius, stroke, strokeWidth, background]
+  row: [fill]
+  cell: [fill, stroke, strokeWidth]
+  vstack: [fill, stroke, strokeWidth, strokeStyle, opacity]
+  hstack: [fill, stroke, strokeWidth, strokeStyle, opacity]
+  group: []
+  overlay: []
+  spacer: []
+  divider: [stroke, strokeWidth]
+
+document:
+  type: root
+  description: "Root node. Defines viewBox"
+  params:
+    width: { from: width, default: 800 }
+    height: { from: height, default: 600 }
+    padding: { from: padding, default: 0 }
+  slots:
+    self: [resolvedWidth, resolvedHeight, availableWidth, availableHeight]
+  operations:
+    - type: set_explicit_size
+
+stack:
+  type: stack
+  description: "Place children sequentially along the main axis"
+  applies_to:
+    vstack:
+      main_slot: localY
+      cross_slot: localX
+      main_size: resolvedHeight
+      cross_size: resolvedWidth
+      content_main_size: contentHeight
+      content_cross_size: contentWidth
+    hstack:
+      main_slot: localX
+      cross_slot: localY
+      main_size: resolvedWidth
+      cross_size: resolvedHeight
+      content_main_size: contentWidth
+      content_cross_size: contentHeight
+    row:
+      main_slot: localX
+      cross_slot: localY
+      main_size: resolvedWidth
+      cross_size: resolvedHeight
+      content_main_size: contentWidth
+      content_cross_size: contentHeight
+  params:
+    gap: { from: gap, default: 0 }
+    padding: { from: padding, default: 0 }
+    align: { from: align, default: start }
+    width: { from: width, default: wrap }
+    height: { from: height, default: wrap }
+  slots:
+    self: [resolvedWidth, resolvedHeight, localX, localY, contentWidth, contentHeight]
+    children: [resolvedWidth, resolvedHeight, localX, localY]
+  children_filter: non_constraint
+  operations:
+    - type: sequential_position
+      description: "Place children along main axis (padding offset + gap between)"
+      input: "children.main_size"
+      output: "children.main_slot"
+      uses: [gap, padding]
+    - type: cross_axis_position
+      description: "Offset cross-axis position by padding"
+      output: "children.cross_slot"
+      uses: [padding, align]
+    - type: content_size_sum
+      description: "Main-axis content size = children sizes + gaps"
+      input: "children.main_size"
+      output: "self.content_main_size"
+      reduce: sum_with_gaps
+      uses: [gap]
+    - type: content_size_max
+      description: "Cross-axis content size = max of children"
+      input: "children.cross_size"
+      output: "self.content_cross_size"
+      reduce: max
+    - type: wrap_main_size
+      description: "wrap: contentSize + 2*padding"
+      input: "self.content_main_size"
+      output: "self.main_size"
+      uses: [padding]
+    - type: wrap_cross_size
+      description: "wrap: max child + 2*padding"
+      input: "self.content_cross_size"
+      output: "self.cross_size"
+      uses: [padding]
+
+box:
+  type: container
+  description: "Container. Size resolution based on child content"
+  params:
+    padding: { from: padding, default: 0 }
+    width: { from: width, default: wrap }
+    height: { from: height, default: wrap }
+  slots:
+    self: [resolvedWidth, resolvedHeight, localX, localY, contentWidth, contentHeight]
+    children: [resolvedWidth, resolvedHeight, localX, localY]
+  size_modes:
+    explicit:
+      operation: set_explicit_size
+      priority: strong
+    wrap:
+      operation: content_plus_padding
+      priority: weak
+      input: "self.contentSize"
+      uses: [padding]
+    fill:
+      operation: copy_parent_available
+      priority: normal
+      input: "parent.availableSize"
+  content_size:
+    description: "Content size = max of child sizes"
+    input: "children.resolvedSize"
+    reduce: max
+
+text:
+  type: text_measurement
+  description: "Intrinsic size from text measurement"
+  params:
+    text: { from: text, default: "" }
+    fontSize: { from: fontSize, default: 14 }
+    fontWeight: { from: fontWeight, default: normal }
+    textAlign: { from: textAlign, default: center }
+    padding: { from: padding, default: 0 }
+  slots:
+    self: [resolvedWidth, resolvedHeight, localX, localY, intrinsicWidth, intrinsicHeight, contentWidth, contentHeight, textBaseline, textX, textAnchor]
+  operations:
+    - type: measure_text
+      output_width: intrinsicWidth
+      output_height: intrinsicHeight
+      uses: [text, fontSize, padding]
+    - type: set_from_intrinsic
+      description: "resolved = intrinsic (text always uses intrinsic size)"
+      priority: normal
+    - type: text_layout
+      description: "Compute text placement (baseline, X, anchor)"
+      uses: [fontSize, textAlign]
+
+label:
+  type: text_measurement
+  inherits: text
+
+group:
+  type: container
+  description: "Structural group. Same size resolution as box"
+  inherits: box
+
+overlay:
+  type: overlay
+  description: "Z-stack. Place all children at (0,0)"
+  params:
+    padding: { from: padding, default: 0 }
+  slots:
+    self: [resolvedWidth, resolvedHeight, localX, localY, contentWidth, contentHeight]
+    children: [resolvedWidth, resolvedHeight, localX, localY]
+  operations:
+    - type: set_children_origin
+      description: "Place all children at (padding, padding)"
+      output: "children.[localX, localY]"
+      uses: [padding]
+    - type: content_size_max
+      description: "Content size = max of children"
+      input: "children.[resolvedWidth, resolvedHeight]"
+      output: "self.[contentWidth, contentHeight]"
+      reduce: max
+
+connector:
+  type: connector
+  description: "Geometry consumer. Compute path from from/to node worldRect"
+  params:
+    from: { from: from }
+    to: { from: to }
+    route: { from: route, default: straight }
+  slots:
+    self: [resolvedWidth, resolvedHeight, localX, localY, connectorPath]
+    depends_on: ["from.worldRect", "to.worldRect"]
+  operations:
+    - type: compute_connector_path
+      input: ["from.worldRect", "to.worldRect"]
+      output: connectorPath
+      uses: [route]
+
+spacer:
+  type: fixed_size
+  description: "Fixed-size blank space"
+  params:
+    width: { from: width, default: 0 }
+    height: { from: height, default: 0 }
+
+divider:
+  type: fixed_size
+  description: "Separator line"
+  params:
+    axis: { from: axis, default: horizontal }
+  size_from_axis:
+    horizontal: { width: fill, height: 1 }
+    vertical: { width: 1, height: fill }
+
+image:
+  type: fixed_size
+  params:
+    width: { from: width, default: 100 }
+    height: { from: height, default: 100 }
+
+icon:
+  type: fixed_size
+  params:
+    width: { default: 24 }
+    height: { default: 24 }
+
+svgAsset:
+  type: fixed_size
+  params:
+    width: { from: width, default: 100 }
+    height: { from: height, default: 100 }
+
+# ---------------------------------------------------------------------------
+# Table \u2014 layout composed from grid rules
+#
+# No dedicated table algorithm. Everything is expressed via generic primitives:
+#   1. Row vertical stacking \u2192 grid handler (sequential_position)
+#   2. Cell horizontal stacking \u2192 stack rule (row = hstack)
+#   3. Column width equalization \u2192 grid handler (column equalization)
+#   4. Row height equalization \u2192 grid handler (row equalization)
+#   5. In-cell placement \u2192 container rule (colAlign \xD7 rowAlign)
+# ---------------------------------------------------------------------------
+
+table:
+  type: grid
+  description: "Grid layout. Column/row equalization via implicit constraints"
+  params:
+    padding: { from: padding, default: 0 }
+    gap: { from: gap, default: 0 }
+  grid:
+    row_kind: row
+    cell_kind: cell
+    row_axis: vertical
+    equalize_columns: width
+    equalize_rows: height
+
+cell:
+  type: container
+  description: "Table cell. Content placement via colAlign/rowAlign"
+  params:
+    padding: { from: padding, default: 4 }
+    colAlign: { from: colAlign, default: left }
+    rowAlign: { from: rowAlign, default: top }
+`;
+var constraintRules = load(CONSTRAINT_RULES_YAML);
+var layoutRules = load(LAYOUT_RULES_YAML);
+var UNIVERSAL_PROPS = /* @__PURE__ */ new Set(["id", "geometry"]);
+function buildAllowedPropsMap() {
+  const map = /* @__PURE__ */ new Map();
+  const stylePropsSection = layoutRules.style_props;
+  const commonStyles = stylePropsSection?._common ?? [];
+  for (const [ruleKey, rule] of Object.entries(layoutRules)) {
+    if (ruleKey === "style_props") continue;
+    const paramNames = rule.params ? Object.entries(rule.params).map(([key, p]) => p.from ?? key) : [];
+    const kindStyleProps = stylePropsSection?.[ruleKey] ?? [];
+    if (rule.applies_to) {
+      for (const subKind of Object.keys(rule.applies_to)) {
+        const set = /* @__PURE__ */ new Set([...UNIVERSAL_PROPS, ...paramNames, ...kindStyleProps, ...commonStyles]);
+        const subStyleProps = stylePropsSection?.[subKind] ?? [];
+        for (const p of subStyleProps) set.add(p);
+        map.set(subKind, set);
+      }
+    } else {
+      const inheritsFrom = rule.inherits ? map.get(rule.inherits) : void 0;
+      const set = /* @__PURE__ */ new Set([
+        ...UNIVERSAL_PROPS,
+        ...paramNames,
+        ...kindStyleProps,
+        ...commonStyles,
+        ...inheritsFrom ?? []
+      ]);
+      map.set(ruleKey, set);
+    }
+  }
+  for (const [constraintKind, rule] of Object.entries(constraintRules)) {
+    const props = new Set(UNIVERSAL_PROPS);
+    props.add("targets");
+    if (rule.axis_mapping || rule.axis_to_slot || rule.axis_to_position_slot) props.add("axis");
+    if (rule.priority_from) props.add(rule.priority_from);
+    if (rule.strategy_from) props.add(rule.strategy_from);
+    if (rule.min_gap_from) props.add(rule.min_gap_from);
+    if (rule.reference || rule.movers) props.add("anchor");
+    if (rule.operation === "world_align") props.add("align");
+    map.set(constraintKind, props);
+  }
+  return map;
+}
+var _allowedPropsMap;
+function getAllowedProps(kind) {
+  if (!_allowedPropsMap) _allowedPropsMap = buildAllowedPropsMap();
+  return _allowedPropsMap.get(kind);
+}
+var MAIN_AXIS_KINDS = {
+  vstack: "localY",
+  hstack: "localX",
+  row: "localX"
+};
+function baseMainSlot(mainSlot) {
+  return mainSlot === "localY" ? "baseLocalY" : "baseLocalX";
+}
+function suffixShiftSlotId(stackId, index) {
+  return slotId(stackId, `suffixShift.${index}`);
+}
+function stackMainAxisContext(targetId, localSlot, graph) {
+  const parentId = graph.parentMap.get(targetId);
+  if (!parentId) return null;
+  const parentKind = graph.nodeKindMap.get(parentId);
+  if (!parentKind) return null;
+  const mainAxis = MAIN_AXIS_KINDS[parentKind];
+  if (!mainAxis || mainAxis !== localSlot) return null;
+  const order = graph.childrenOrderMap.get(parentId);
+  if (!order) return null;
+  const index = order.indexOf(targetId);
+  if (index < 0) return null;
+  return { stackId: parentId, index };
+}
+function pickReferenceTarget(targets, localSlot, graph, anchorProp, moverProp) {
+  if (anchorProp) {
+    return {
+      reference: anchorProp,
+      movers: targets.filter((t) => t !== anchorProp)
+    };
+  }
+  if (moverProp) {
+    const reference2 = targets.find((t) => t !== moverProp) ?? targets[0];
+    return { reference: reference2, movers: [moverProp] };
+  }
+  const scored = targets.map((t) => ({ id: t, score: computeFreedomScore(t, localSlot, graph) }));
+  const allMainAxis = scored.every((s) => s.score === 0);
+  if (allMainAxis) {
+    const stackParents = new Set(
+      targets.map((t) => graph.parentMap.get(t)).filter((p) => p !== void 0)
+    );
+    if (stackParents.size === 1) {
+      const stackId = [...stackParents][0];
+      const order = graph.childrenOrderMap.get(stackId);
+      if (order) {
+        let maxIdx = -1;
+        let reference2 = targets[0];
+        for (const t of targets) {
+          const idx = order.indexOf(t);
+          if (idx > maxIdx) {
+            maxIdx = idx;
+            reference2 = t;
+          }
+        }
+        return { reference: reference2, movers: targets.filter((t) => t !== reference2) };
+      }
+    }
+  }
+  scored.sort((a, b) => a.score - b.score);
+  const reference = scored[0].id;
+  return { reference, movers: scored.slice(1).map((s) => s.id) };
+}
+function computeFreedomScore(targetId, localSlot, graph) {
+  const parentId = graph.parentMap.get(targetId);
+  if (!parentId) return 4;
+  const parentKind = graph.nodeKindMap.get(parentId);
+  if (!parentKind) return 4;
+  if (parentKind === "document") return 4;
+  if (parentKind === "absolute") return 3;
+  const mainAxis = MAIN_AXIS_KINDS[parentKind];
+  if (mainAxis) {
+    return mainAxis === localSlot ? 0 : 2;
+  }
+  if (parentKind === "table" || parentKind === "cell" || parentKind === "grid") return 0;
+  if (parentKind === "overlay") return 1;
+  return 2;
+}
+function describeFreedomContext(targetId, localSlot, graph) {
+  const parentId = graph.parentMap.get(targetId);
+  if (!parentId) return "root child";
+  const parentKind = graph.nodeKindMap.get(parentId) ?? "unknown";
+  const mainAxis = MAIN_AXIS_KINDS[parentKind];
+  if (mainAxis && mainAxis === localSlot) {
+    return `main-axis child of ${parentKind}(${parentId})`;
+  }
+  if (mainAxis && mainAxis !== localSlot) {
+    return `cross-axis child of ${parentKind}(${parentId})`;
+  }
+  return `child of ${parentKind}(${parentId})`;
+}
+function collectPathLocalSlots(fromId, toAncestorId, localSlotKind, graph) {
+  const slots = [];
+  let current = fromId;
+  while (current !== toAncestorId) {
+    ensureSlot(graph, current, localSlotKind);
+    slots.push(slotId(current, localSlotKind));
+    const parent = graph.parentMap.get(current);
+    if (!parent) break;
+    current = parent;
+  }
+  return slots;
+}
+function applyWorldAlign(rule, node, graph) {
+  const targets = node.props.targets;
+  if (!targets || targets.length < 2) return;
+  const axis = node.props.axis ?? "horizontal";
+  const alignMode = node.props.align ?? "start";
+  const strength = node.props.strength ?? rule.default_priority;
+  const mapping = rule.axis_mapping;
+  if (!mapping) return;
+  const axisMap = mapping[axis];
+  if (!axisMap) return;
+  const { world_slot: worldSlot, local_slot: localSlot, size_slot: sizeSlot } = axisMap;
+  let reference;
+  let movers;
+  const anchorProp = node.props.anchor;
+  const moverProp = node.props.mover;
+  if (anchorProp) {
+    if (!targets.includes(anchorProp)) {
+      graph.diagnostics.push({
+        level: "error",
+        message: `AlignConstraint(${node.id}): anchor="${anchorProp}" is not in targets [${targets.join(", ")}].`,
+        path: node.id ?? ""
+      });
+      return;
+    }
+  }
+  ({ reference, movers } = pickReferenceTarget(targets, localSlot, graph, anchorProp, moverProp));
+  if (moverProp) {
+    const score = computeFreedomScore(moverProp, localSlot, graph);
+    if (score <= 0) {
+      graph.diagnostics.push({
+        level: "warning",
+        message: `AlignConstraint(${node.id}): mover="${moverProp}" is ${describeFreedomContext(moverProp, localSlot, graph)}. Aligning may break sibling layout.`,
+        path: node.id ?? ""
+      });
+    }
+  } else if (!anchorProp) {
+    const scored = targets.map((t) => ({ id: t, score: computeFreedomScore(t, localSlot, graph) }));
+    const allLow = scored.every((s) => s.score <= 0);
+    const allMainAxis = scored.every((s) => s.score === 0);
+    const sameStackAllMain = allMainAxis && new Set(targets.map((t) => graph.parentMap.get(t))).size === 1;
+    if (allLow && !sameStackAllMain) {
+      graph.diagnostics.push({
+        level: "warning",
+        message: `AlignConstraint(${node.id}): all targets have low freedom on ${localSlot}. Alignment may break sibling layout. ` + targets.map((t) => `${t} is ${describeFreedomContext(t, localSlot, graph)}`).join("; ") + ".",
+        path: node.id ?? ""
+      });
+    }
+  }
+  const alignRefs = node.props.alignRefs ?? {};
+  const refMeasure = alignRefs[reference] ?? reference;
+  ensureSlot(graph, refMeasure, worldSlot);
+  if (alignMode !== "start") {
+    ensureSlot(graph, refMeasure, sizeSlot);
+  }
+  for (const moverId of movers) {
+    const moverParentId = graph.parentMap.get(moverId);
+    if (!moverParentId) continue;
+    const moverMeasure = alignRefs[moverId] ?? moverId;
+    const stackCtx = stackMainAxisContext(moverId, localSlot, graph);
+    const refStackCtx = stackMainAxisContext(reference, localSlot, graph);
+    const hasMoverPath = moverMeasure !== moverId;
+    const useSuffixShift = stackCtx !== null && !hasMoverPath && (refStackCtx === null || refStackCtx.stackId === stackCtx.stackId || anchorProp !== void 0);
+    if (useSuffixShift && stackCtx) {
+      applySuffixShiftAlign(
+        graph,
+        node,
+        moverId,
+        stackCtx.stackId,
+        stackCtx.index,
+        refMeasure,
+        moverMeasure,
+        alignMode,
+        strength,
+        worldSlot,
+        baseMainSlot(localSlot),
+        sizeSlot,
+        localSlot
+      );
+      continue;
+    }
+    ensureSlot(graph, moverParentId, worldSlot);
+    ensureSlot(graph, moverId, localSlot);
+    const opId = `op.${node.kind}.${node.id}.${moverId}.${localSlot}`;
+    const outputSlotId = slotId(moverId, localSlot);
+    const inputSlots = [
+      slotId(refMeasure, worldSlot),
+      slotId(moverParentId, worldSlot)
+    ];
+    const localSlotKind = localSlot;
+    if (alignMode === "center" || alignMode === "end") {
+      ensureSlot(graph, refMeasure, sizeSlot);
+      inputSlots.push(slotId(refMeasure, sizeSlot));
+      if (moverMeasure === moverId) {
+        ensureSlot(graph, moverId, sizeSlot);
+        inputSlots.push(slotId(moverId, sizeSlot));
+      } else {
+        const pathLocalYSlots = collectPathLocalSlots(
+          moverMeasure,
+          moverId,
+          localSlotKind,
+          graph
+        );
+        ensureSlot(graph, moverMeasure, sizeSlot);
+        for (const s of pathLocalYSlots) inputSlots.push(s);
+        inputSlots.push(slotId(moverMeasure, sizeSlot));
+      }
+    }
+    addCandidate(graph, outputSlotId, void 0, `${node.kind}(${node.id})`, strength, opId);
+    addOperation(graph, opId, "alignDelta", inputSlots, [outputSlotId], (inputs) => {
+      const refWorld = inputs[0] ?? 0;
+      const moverParentWorld = inputs[1] ?? 0;
+      if (alignMode === "center") {
+        const refSize = inputs[2] ?? 0;
+        const refCenter = refWorld + refSize / 2;
+        if (!hasMoverPath) {
+          const moverSize = inputs[3] ?? 0;
+          return [refCenter - moverParentWorld - moverSize / 2];
+        }
+        const pathSlots = inputs.slice(3, -1);
+        const moverMeasureSize = inputs[inputs.length - 1] ?? 0;
+        const internalOffset = pathSlots.reduce((sum, v) => sum + (v ?? 0), 0) + moverMeasureSize / 2;
+        return [refCenter - moverParentWorld - internalOffset];
+      }
+      if (alignMode === "end") {
+        const refSize = inputs[2] ?? 0;
+        const refEnd = refWorld + refSize;
+        if (!hasMoverPath) {
+          const moverSize = inputs[3] ?? 0;
+          return [refEnd - moverParentWorld - moverSize];
+        }
+        const pathSlots = inputs.slice(3, -1);
+        const moverMeasureSize = inputs[inputs.length - 1] ?? 0;
+        const internalOffset = pathSlots.reduce((sum, v) => sum + (v ?? 0), 0) + moverMeasureSize;
+        return [refEnd - moverParentWorld - internalOffset];
+      }
+      return [refWorld - moverParentWorld];
+    });
+  }
+}
+function applySuffixShiftAlign(graph, node, moverId, stackId, index, refMeasure, moverMeasure, alignMode, strength, worldSlot, baseMainSlotKind, sizeSlot, _localSlot) {
+  const ssSlotId = suffixShiftSlotId(stackId, index);
+  ensureSlot(graph, stackId, `suffixShift.${index}`);
+  addResolver(graph, ssSlotId, "max");
+  ensureSlot(graph, refMeasure, worldSlot);
+  ensureSlot(graph, stackId, worldSlot);
+  ensureSlot(graph, moverId, baseMainSlotKind);
+  const opId = `op.${node.kind}.${node.id}.${moverId}.suffixShift`;
+  addCandidate(graph, ssSlotId, void 0, `${node.kind}(${node.id}).suffix`, strength, opId);
+  const inputSlots = [
+    slotId(refMeasure, worldSlot),
+    slotId(stackId, worldSlot),
+    slotId(moverId, baseMainSlotKind)
+  ];
+  if (alignMode === "center" || alignMode === "end") {
+    ensureSlot(graph, refMeasure, sizeSlot);
+    inputSlots.push(slotId(refMeasure, sizeSlot));
+    ensureSlot(graph, moverMeasure, sizeSlot);
+    inputSlots.push(slotId(moverMeasure, sizeSlot));
+  }
+  addOperation(graph, opId, "suffixShiftDelta", inputSlots, [ssSlotId], (inputs) => {
+    const refWorld = inputs[0] ?? 0;
+    const stackWorld = inputs[1] ?? 0;
+    const baseLocal = inputs[2] ?? 0;
+    let delta;
+    if (alignMode === "center") {
+      const refSize = inputs[3] ?? 0;
+      const moverSize = inputs[4] ?? 0;
+      delta = refWorld + refSize / 2 - stackWorld - baseLocal - moverSize / 2;
+    } else if (alignMode === "end") {
+      const refSize = inputs[3] ?? 0;
+      const moverSize = inputs[4] ?? 0;
+      delta = refWorld + refSize - stackWorld - baseLocal - moverSize;
+    } else {
+      delta = refWorld - stackWorld - baseLocal;
+    }
+    return [Math.max(0, delta)];
+  });
+}
+function applyEqualize(rule, node, graph) {
+  const targets = node.props.targets;
+  if (!targets || targets.length < 2) return;
+  const strength = node.props.strength ?? rule.default_priority;
+  const strategy = node.props.strategy ?? rule.default_strategy ?? "max";
+  const outputSlotName = rule.slot;
+  const inputSlotName = rule.content_slot;
+  if (!outputSlotName || !inputSlotName) return;
+  const constraintId = node.id;
+  const aggSlotId = `${constraintId}._agg`;
+  ensureSlot(graph, constraintId, "_agg");
+  const gatherOpId = `op.${node.kind}.${constraintId}.gather`;
+  const gatherInputs = [];
+  for (const targetId of targets) {
+    ensureSlot(graph, targetId, inputSlotName);
+    gatherInputs.push(slotId(targetId, inputSlotName));
+  }
+  addCandidate(graph, aggSlotId, void 0, `${node.kind}(${constraintId}).agg`, "required", gatherOpId);
+  addOperation(graph, gatherOpId, strategy, gatherInputs, [aggSlotId], (inputs) => {
+    const vals = inputs.map((v) => v ?? 0);
+    switch (strategy) {
+      case "min":
+        return [Math.min(...vals)];
+      case "first":
+        return [vals[0] ?? 0];
+      default:
+        return [Math.max(...vals)];
+    }
+  });
+  const distributeOpId = `op.${node.kind}.${constraintId}.dist`;
+  const distributeOutputs = [];
+  for (const targetId of targets) {
+    ensureSlot(graph, targetId, outputSlotName);
+    const sid = slotId(targetId, outputSlotName);
+    distributeOutputs.push(sid);
+    addCandidate(graph, sid, void 0, `${node.kind}(${constraintId})`, strength, distributeOpId);
+  }
+  addOperation(graph, distributeOpId, "copy", [aggSlotId], distributeOutputs, (inputs) => {
+    return targets.map(() => inputs[0] ?? 0);
+  });
+}
+function applyEnforceOrder(rule, node, graph) {
+  const targets = node.props.targets;
+  if (!targets || targets.length < 2) return;
+  const axis = node.props.axis ?? "vertical";
+  const strength = node.props.strength ?? rule.default_priority;
+  const posSlot = rule.axis_to_slot[axis];
+  const sizeSlot = rule.axis_to_size_slot[axis];
+  for (let i = 1; i < targets.length; i++) {
+    const prev = targets[i - 1];
+    const curr = targets[i];
+    ensureSlot(graph, prev, posSlot);
+    ensureSlot(graph, prev, sizeSlot);
+    ensureSlot(graph, curr, posSlot);
+    const opId = `op.order.${node.id}.${i}`;
+    const inputSlots = [`${prev}.${posSlot}`, `${prev}.${sizeSlot}`];
+    const outputSlotId = `${curr}.${posSlot}`;
+    addCandidate(graph, outputSlotId, void 0, `order(${node.id})`, strength, opId);
+    addOperation(graph, opId, "identity", inputSlots, [outputSlotId], (inputs) => {
+      const prevPos = inputs[0] ?? 0;
+      const prevSize = inputs[1] ?? 0;
+      return [prevPos + prevSize];
+    });
+  }
+}
+function applyEnforceMinGap(rule, node, graph) {
+  const targets = node.props.targets;
+  if (!targets || targets.length < 2) return;
+  const axis = node.props.axis ?? "vertical";
+  const strength = node.props.strength ?? rule.default_priority;
+  const posSlot = rule.axis_to_position_slot[axis];
+  const sizeSlot = rule.axis_to_size_slot[axis];
+  const minGap = getNumericProp(node, rule.min_gap_from, 0);
+  for (let i = 1; i < targets.length; i++) {
+    const prev = targets[i - 1];
+    const curr = targets[i];
+    ensureSlot(graph, prev, posSlot);
+    ensureSlot(graph, prev, sizeSlot);
+    ensureSlot(graph, curr, posSlot);
+    const opId = `op.gap.${node.id}.${i}`;
+    const inputSlots = [`${prev}.${posSlot}`, `${prev}.${sizeSlot}`];
+    const outputSlotId = `${curr}.${posSlot}`;
+    addCandidate(graph, outputSlotId, void 0, `gap(${node.id})`, strength, opId);
+    addOperation(graph, opId, "identity", inputSlots, [outputSlotId], (inputs) => {
+      const prevPos = inputs[0] ?? 0;
+      const prevSize = inputs[1] ?? 0;
+      return [prevPos + prevSize + minGap];
+    });
+  }
+}
+function applyClampInside(rule, node, graph) {
+  const targets = node.props.targets;
+  if (!targets || targets.length < 2) return;
+  const strength = node.props.strength ?? rule.default_priority;
+  const containerId = targets[0];
+  const contentIds = targets.slice(1);
+  for (const contentId of contentIds) {
+    for (let pi = 0; pi < rule.position_slots.length; pi++) {
+      const posSlot = rule.position_slots[pi];
+      const sizeSlot = rule.size_slots[pi];
+      const containerSizeSlot = sizeSlot;
+      ensureSlot(graph, containerId, containerSizeSlot);
+      ensureSlot(graph, contentId, posSlot);
+      ensureSlot(graph, contentId, sizeSlot);
+      const opId = `op.keepInside.${node.id}.${contentId}.${posSlot}`;
+      const inputSlots = [
+        `${containerId}.${containerSizeSlot}`,
+        `${contentId}.${posSlot}`,
+        `${contentId}.${sizeSlot}`
+      ];
+      const outputSlotId = `${contentId}.${posSlot}`;
+      addCandidate(graph, outputSlotId, void 0, `keepInside(${node.id})`, strength, opId);
+      addOperation(graph, opId, "clamp", inputSlots, [outputSlotId], (inputs) => {
+        const containerSize = inputs[0] ?? 0;
+        const currentPos = inputs[1] ?? 0;
+        const contentSize = inputs[2] ?? 0;
+        const maxPos = containerSize - contentSize;
+        return [Math.max(0, Math.min(currentPos, maxPos))];
+      });
+    }
+  }
+}
+var CONSTRAINT_HANDLERS = {
+  world_align: applyWorldAlign,
+  equalize: applyEqualize,
+  enforce_order: applyEnforceOrder,
+  enforce_min_gap: applyEnforceMinGap,
+  clamp_inside: applyClampInside
+};
+function applyConstraintFromRule(kind, node, graph) {
+  const rule = constraintRules[kind];
+  if (!rule) return false;
+  const handler = CONSTRAINT_HANDLERS[rule.operation];
+  if (!handler) return false;
+  handler(rule, node, graph);
+  return true;
+}
+var textMeasurer = new SimpleTextMeasurer();
+function applyRootRule(rule, node, graph) {
+  const id = node.id;
+  const width = getNumericProp(node, "width", rule.params?.width?.default ?? 800);
+  const height = getNumericProp(node, "height", rule.params?.height?.default ?? 600);
+  const padding = getNumericProp(node, "padding", rule.params?.padding?.default ?? 0);
+  ensureSlot(graph, id, "resolvedWidth", width);
+  ensureSlot(graph, id, "resolvedHeight", height);
+  ensureSlot(graph, id, "availableWidth", width - padding * 2);
+  ensureSlot(graph, id, "availableHeight", height - padding * 2);
+  addCandidate(graph, slotId(id, "resolvedWidth"), width, "document(explicit)", "required");
+  addCandidate(graph, slotId(id, "resolvedHeight"), height, "document(explicit)", "required");
+  if (padding > 0 && node.children) {
+    for (const child of node.children) {
+      if (child.id && !isConstraintKind(child.kind)) {
+        ensureSlot(graph, child.id, "localX");
+        ensureSlot(graph, child.id, "localY");
+        addCandidate(graph, slotId(child.id, "localX"), padding, `document(${id}).padding`, "weak");
+        addCandidate(graph, slotId(child.id, "localY"), padding, `document(${id}).padding`, "weak");
+      }
+    }
+  }
+}
+function applyStackRule(_rule, axisConfig, kindName, node, graph, parentId) {
+  const id = node.id;
+  const gap = getNumericProp(node, "gap", 0);
+  const padding = getNumericProp(node, "padding", 0);
+  const children = node.children ?? [];
+  registerSizeSlots(node, graph, parentId);
+  ensureSlot(graph, id, "contentWidth");
+  ensureSlot(graph, id, "contentHeight");
+  const childIds = children.filter((c) => !isConstraintKind(c.kind)).map((c) => c.id);
+  if (childIds.length === 0) return;
+  graph.childrenOrderMap.set(id, childIds);
+  const mainSlot = axisConfig.main_slot;
+  const crossSlot = axisConfig.cross_slot;
+  const mainSize = axisConfig.main_size;
+  const crossSize = axisConfig.cross_size;
+  const contentMainSize = axisConfig.content_main_size;
+  const contentCrossSize = axisConfig.content_cross_size;
+  const baseMain = baseMainSlot(mainSlot);
+  const opId = `op.${kindName}.${id}`;
+  const inputSlots = [];
+  for (const childId of childIds) {
+    ensureSlot(graph, childId, mainSize);
+    ensureSlot(graph, childId, crossSize);
+    ensureSlot(graph, childId, baseMain);
+    ensureSlot(graph, childId, crossSlot);
+    inputSlots.push(slotId(childId, mainSize));
+  }
+  const baseOutputs = [
+    ...childIds.map((cid) => slotId(cid, baseMain)),
+    slotId(id, contentMainSize),
+    slotId(id, mainSize)
+  ];
+  for (const cid of childIds) {
+    addCandidate(graph, slotId(cid, baseMain), void 0, `${kindName}(${id})`, "strong", opId);
+  }
+  addCandidate(graph, slotId(id, contentMainSize), void 0, `${kindName}(${id}).content`, "strong", opId);
+  addCandidate(graph, slotId(id, mainSize), void 0, `${kindName}(${id}).wrap`, "normal", opId);
+  addOperation(graph, opId, "stackPosition", inputSlots, baseOutputs, (inputs) => {
+    let pos = padding;
+    const positions = [];
+    for (let i = 0; i < inputs.length; i++) {
+      positions.push(pos);
+      pos += inputs[i] + (i < inputs.length - 1 ? gap : 0);
+    }
+    const contentMain = pos - padding;
+    const totalMain = contentMain + padding * 2;
+    return [...positions, contentMain, totalMain];
+  });
+  const suffixShiftSlotIds = [];
+  for (let i = 0; i < childIds.length; i++) {
+    const ssId = suffixShiftSlotId(id, i);
+    ensureSlot(graph, id, `suffixShift.${i}`);
+    addCandidate(graph, ssId, 0, `${kindName}(${id}).suffixShift.${i}`, "weak");
+    addResolver(graph, ssId, "max");
+    suffixShiftSlotIds.push(ssId);
+  }
+  const composeOpId = `op.${kindName}.compose.${id}`;
+  const composeInputs = [
+    ...childIds.map((cid) => slotId(cid, baseMain)),
+    ...suffixShiftSlotIds
+  ];
+  const composeOutputs = childIds.map((cid) => slotId(cid, mainSlot));
+  for (const cid of childIds) {
+    addCandidate(graph, slotId(cid, mainSlot), void 0, `${kindName}(${id}).compose`, "strong", composeOpId);
+  }
+  addOperation(graph, composeOpId, "stackCompose", composeInputs, composeOutputs, (inputs) => {
+    const n = childIds.length;
+    const bases = inputs.slice(0, n);
+    const shifts = inputs.slice(n, n + n);
+    let runningMax = 0;
+    const result = [];
+    for (let j = 0; j < n; j++) {
+      runningMax = Math.max(runningMax, shifts[j] ?? 0);
+      result.push((bases[j] ?? 0) + runningMax);
+    }
+    return result;
+  });
+  const align = node.props.align ?? "start";
+  const crossPropName = crossSize === "resolvedWidth" ? "width" : "height";
+  const availableCrossSlot = crossSize === "resolvedWidth" ? "availableWidth" : "availableHeight";
+  const selfCrossIntent = getSizeProp(node, crossPropName);
+  const contentChildren = children.filter((c) => !isConstraintKind(c.kind));
+  const fillChildIndices = /* @__PURE__ */ new Set();
+  for (let i = 0; i < childIds.length; i++) {
+    if (getSizeProp(contentChildren[i], crossPropName) === "fill") {
+      fillChildIndices.add(i);
+    }
+  }
+  const crossInputSlots = [];
+  for (let i = 0; i < childIds.length; i++) {
+    if (!fillChildIndices.has(i)) {
+      crossInputSlots.push(slotId(childIds[i], crossSize));
+    }
+  }
+  const maxCrossOpId = `op.${kindName}.maxCross.${id}`;
+  addCandidate(graph, slotId(id, contentCrossSize), void 0, `${kindName}(${id}).contentCross`, "strong", maxCrossOpId);
+  addOperation(graph, maxCrossOpId, "max", crossInputSlots, [slotId(id, contentCrossSize)], (inputs) => {
+    return [inputs.length > 0 ? Math.max(...inputs) : 0];
+  });
+  ensureSlot(graph, id, availableCrossSlot);
+  const availCrossOpId = `op.${kindName}.availCross.${id}`;
+  const availCrossInputs = [slotId(id, contentCrossSize)];
+  if (selfCrossIntent === "fill" && parentId) {
+    const parentAvailSlot = crossSize === "resolvedWidth" ? "availableWidth" : "availableHeight";
+    ensureSlot(graph, parentId, parentAvailSlot);
+    availCrossInputs.push(slotId(parentId, parentAvailSlot));
+  }
+  addCandidate(graph, slotId(id, availableCrossSlot), void 0, `${kindName}(${id}).availCross`, "strong", availCrossOpId);
+  addOperation(graph, availCrossOpId, "max", availCrossInputs, [slotId(id, availableCrossSlot)], (inputs) => {
+    const contentCross = inputs[0] ?? 0;
+    const parentAvail = inputs.length > 1 ? (inputs[1] ?? 0) - padding * 2 : 0;
+    return [Math.max(contentCross, parentAvail)];
+  });
+  const wrapCrossOpId = `op.${kindName}.wrapCross.${id}`;
+  addCandidate(graph, slotId(id, crossSize), void 0, `${kindName}(${id}).wrapCross`, "normal", wrapCrossOpId);
+  addOperation(graph, wrapCrossOpId, "resolveSize", [slotId(id, availableCrossSlot)], [slotId(id, crossSize)], (inputs) => {
+    return [(inputs[0] ?? 0) + padding * 2];
+  });
+  const crossAlignOpId = `op.${kindName}.crossAlign.${id}`;
+  const allChildCrossSlots = childIds.map((cid) => slotId(cid, crossSize));
+  const crossAlignInputs = [slotId(id, availableCrossSlot), ...allChildCrossSlots];
+  const crossAlignOutputs = childIds.map((cid) => slotId(cid, crossSlot));
+  for (const cid of childIds) {
+    addCandidate(graph, slotId(cid, crossSlot), void 0, `${kindName}(${id}).crossAlign`, "strong", crossAlignOpId);
+  }
+  addOperation(graph, crossAlignOpId, "crossAlign", crossAlignInputs, crossAlignOutputs, (inputs) => {
+    const availCross = inputs[0] ?? 0;
+    const positions = [];
+    for (let i = 0; i < childIds.length; i++) {
+      const childCross = inputs[1 + i] ?? 0;
+      let crossPos = padding;
+      if (align === "center") {
+        crossPos = padding + (availCross - childCross) / 2;
+      } else if (align === "end") {
+        crossPos = padding + availCross - childCross;
+      }
+      positions.push(crossPos);
+    }
+    return positions;
+  });
+}
+function applyContainerRule(rule, node, graph, parentId) {
+  const id = node.id;
+  const padding = getNumericProp(node, "padding", rule.params?.padding?.default ?? 0);
+  registerSizeSlots(node, graph, parentId);
+  ensureSlot(graph, id, "contentWidth");
+  ensureSlot(graph, id, "contentHeight");
+  const widthIntent = getSizeProp(node, "width");
+  const heightIntent = getSizeProp(node, "height");
+  if (widthIntent === "fill" && parentId) {
+    const opId = `op.box.fillWidth.${id}`;
+    const outSid = slotId(id, "resolvedWidth");
+    ensureSlot(graph, parentId, "availableWidth");
+    addCandidate(graph, outSid, void 0, `box(${id}).fill`, "normal", opId);
+    addOperation(graph, opId, "resolveSize", [slotId(parentId, "availableWidth")], [outSid], (inputs) => {
+      return [inputs[0] ?? 0];
+    });
+  }
+  if (heightIntent === "fill" && parentId) {
+    const opId = `op.box.fillHeight.${id}`;
+    const outSid = slotId(id, "resolvedHeight");
+    ensureSlot(graph, parentId, "availableHeight");
+    addCandidate(graph, outSid, void 0, `box(${id}).fill`, "normal", opId);
+    addOperation(graph, opId, "resolveSize", [slotId(parentId, "availableHeight")], [outSid], (inputs) => {
+      return [inputs[0] ?? 0];
+    });
+  }
+  const wrapWidthOpId = `op.box.wrapWidth.${id}`;
+  const wrapHeightOpId = `op.box.wrapHeight.${id}`;
+  if (widthIntent === "wrap") {
+    const outSid = slotId(id, "resolvedWidth");
+    addCandidate(graph, outSid, void 0, `box(${id}).wrap`, "weak", wrapWidthOpId);
+    addOperation(graph, wrapWidthOpId, "resolveSize", [slotId(id, "contentWidth")], [outSid], (inputs) => {
+      return [(inputs[0] ?? 0) + padding * 2];
+    });
+  }
+  if (heightIntent === "wrap") {
+    const outSid = slotId(id, "resolvedHeight");
+    addCandidate(graph, outSid, void 0, `box(${id}).wrap`, "weak", wrapHeightOpId);
+    addOperation(graph, wrapHeightOpId, "resolveSize", [slotId(id, "contentHeight")], [outSid], (inputs) => {
+      return [(inputs[0] ?? 0) + padding * 2];
+    });
+  }
+  const availWidthOpId = `op.box.availW.${id}`;
+  ensureSlot(graph, id, "availableWidth");
+  addCandidate(graph, slotId(id, "availableWidth"), void 0, `box(${id}).availW`, "normal", availWidthOpId);
+  addOperation(graph, availWidthOpId, "resolveSize", [slotId(id, "resolvedWidth")], [slotId(id, "availableWidth")], (inputs) => {
+    return [Math.max((inputs[0] ?? 0) - padding * 2, 0)];
+  });
+  const availHeightOpId = `op.box.availH.${id}`;
+  ensureSlot(graph, id, "availableHeight");
+  addCandidate(graph, slotId(id, "availableHeight"), void 0, `box(${id}).availH`, "normal", availHeightOpId);
+  addOperation(graph, availHeightOpId, "resolveSize", [slotId(id, "resolvedHeight")], [slotId(id, "availableHeight")], (inputs) => {
+    return [Math.max((inputs[0] ?? 0) - padding * 2, 0)];
+  });
+  const children = node.children ?? [];
+  const contentChildIds = children.filter((c) => !isConstraintKind(c.kind)).map((c) => c.id);
+  if (contentChildIds.length > 0) {
+    for (const childId of contentChildIds) {
+      ensureSlot(graph, childId, "resolvedWidth");
+      ensureSlot(graph, childId, "resolvedHeight");
+      ensureSlot(graph, childId, "localX");
+      ensureSlot(graph, childId, "localY");
+    }
+    const contentOpId = `op.box.content.${id}`;
+    const childWidthSlots = contentChildIds.map((cid) => slotId(cid, "resolvedWidth"));
+    const childHeightSlots = contentChildIds.map((cid) => slotId(cid, "resolvedHeight"));
+    const allInputs = [...childWidthSlots, ...childHeightSlots];
+    const contentOutputs = [slotId(id, "contentWidth"), slotId(id, "contentHeight")];
+    addCandidate(graph, slotId(id, "contentWidth"), void 0, `box(${id}).childContent`, "normal", contentOpId);
+    addCandidate(graph, slotId(id, "contentHeight"), void 0, `box(${id}).childContent`, "normal", contentOpId);
+    addOperation(graph, contentOpId, "resolveSize", allInputs, contentOutputs, (inputs) => {
+      const nChildren = contentChildIds.length;
+      const widths = inputs.slice(0, nChildren);
+      const heights = inputs.slice(nChildren);
+      return [Math.max(...widths, 0), Math.max(...heights, 0)];
+    });
+    const hasAlignParams = rule.params?.colAlign !== void 0;
+    const colAlign = hasAlignParams ? node.props.colAlign ?? rule.params.colAlign.default : void 0;
+    const rowAlign = hasAlignParams ? node.props.rowAlign ?? rule.params.rowAlign.default : void 0;
+    const alignOpId = `op.box.center.${id}`;
+    const alignInputs = [slotId(id, "resolvedWidth"), slotId(id, "resolvedHeight"), ...childWidthSlots, ...childHeightSlots];
+    const alignOutputs = contentChildIds.flatMap((cid) => [slotId(cid, "localX"), slotId(cid, "localY")]);
+    for (const cid of contentChildIds) {
+      addCandidate(graph, slotId(cid, "localX"), void 0, `box(${id}).center`, "normal", alignOpId);
+      addCandidate(graph, slotId(cid, "localY"), void 0, `box(${id}).center`, "normal", alignOpId);
+    }
+    addOperation(graph, alignOpId, "resolveSize", alignInputs, alignOutputs, (inputs) => {
+      const boxW = inputs[0] ?? 0;
+      const boxH = inputs[1] ?? 0;
+      const nChildren = contentChildIds.length;
+      const result = [];
+      for (let i = 0; i < nChildren; i++) {
+        const cw = inputs[2 + i] ?? 0;
+        const ch = inputs[2 + nChildren + i] ?? 0;
+        let cx;
+        if (colAlign !== void 0) {
+          switch (colAlign) {
+            case "center":
+              cx = (boxW - cw) / 2;
+              break;
+            case "right":
+              cx = boxW - cw - padding;
+              break;
+            default:
+              cx = padding;
+              break;
+          }
+        } else {
+          cx = (boxW - cw) / 2;
+        }
+        let cy;
+        if (rowAlign !== void 0) {
+          switch (rowAlign) {
+            case "center":
+              cy = (boxH - ch) / 2;
+              break;
+            case "bottom":
+              cy = boxH - ch - padding;
+              break;
+            default:
+              cy = padding;
+              break;
+          }
+        } else {
+          cy = (boxH - ch) / 2;
+        }
+        result.push(cx, cy);
+      }
+      return result;
+    });
+  }
+}
+function applyTextMeasurementRule(_rule, node, graph, parentId) {
+  const id = node.id;
+  const text = node.props.text ?? "";
+  const fontSize = getNumericProp(node, "fontSize", 14);
+  const padding = getNumericProp(node, "padding", 0);
+  const textAlign = node.props.textAlign ?? "center";
+  ensureSlot(graph, id, "resolvedWidth");
+  ensureSlot(graph, id, "resolvedHeight");
+  ensureSlot(graph, id, "localX");
+  ensureSlot(graph, id, "localY");
+  const fontWeight = node.props.fontWeight;
+  const measurement = textMeasurer.measure(text, fontSize, void 0, fontWeight);
+  const intrinsicW = measurement.width + padding * 2;
+  const intrinsicH = measurement.height + padding * 2;
+  ensureSlot(graph, id, "intrinsicWidth", intrinsicW);
+  ensureSlot(graph, id, "intrinsicHeight", intrinsicH);
+  addCandidate(graph, slotId(id, "resolvedWidth"), intrinsicW, `text(${id}).intrinsic`, "normal");
+  addCandidate(graph, slotId(id, "resolvedHeight"), intrinsicH, `text(${id}).intrinsic`, "normal");
+  if (parentId) {
+    ensureSlot(graph, id, "contentWidth", intrinsicW);
+    ensureSlot(graph, id, "contentHeight", intrinsicH);
+  }
+  const lineCount = measurement.lines.length;
+  const lineHeight = fontSize * 1.3;
+  const totalTextHeight = lineHeight * lineCount;
+  let textAnchorVal;
+  switch (textAlign) {
+    case "left":
+      textAnchorVal = 0;
+      break;
+    case "right":
+      textAnchorVal = 2;
+      break;
+    default:
+      textAnchorVal = 1;
+      break;
+  }
+  ensureSlot(graph, id, "textBaseline");
+  ensureSlot(graph, id, "textX");
+  ensureSlot(graph, id, "textAnchor");
+  const textLayoutOpId = `op.textLayout.${id}`;
+  const textLayoutInputs = [slotId(id, "resolvedWidth"), slotId(id, "resolvedHeight")];
+  const textLayoutOutputs = [slotId(id, "textBaseline"), slotId(id, "textX"), slotId(id, "textAnchor")];
+  addCandidate(graph, slotId(id, "textBaseline"), void 0, `text(${id}).layout`, "normal", textLayoutOpId);
+  addCandidate(graph, slotId(id, "textX"), void 0, `text(${id}).layout`, "normal", textLayoutOpId);
+  addCandidate(graph, slotId(id, "textAnchor"), void 0, `text(${id}).layout`, "normal", textLayoutOpId);
+  addOperation(graph, textLayoutOpId, "identity", textLayoutInputs, textLayoutOutputs, (inputs) => {
+    const w = inputs[0] ?? 0;
+    const h = inputs[1] ?? 0;
+    const baseline = (h - totalTextHeight) / 2 + fontSize;
+    let tx;
+    switch (textAnchorVal) {
+      case 0:
+        tx = 0;
+        break;
+      case 2:
+        tx = w;
+        break;
+      default:
+        tx = w / 2;
+        break;
+    }
+    return [baseline, tx, textAnchorVal];
+  });
+}
+function applyOverlayRule(_rule, node, graph, parentId) {
+  const id = node.id;
+  registerSizeSlots(node, graph, parentId);
+  ensureSlot(graph, id, "contentWidth");
+  ensureSlot(graph, id, "contentHeight");
+  const children = node.children ?? [];
+  const childIds = children.filter((c) => !isConstraintKind(c.kind)).map((c) => c.id);
+  for (const childId of childIds) {
+    ensureSlot(graph, childId, "localX", 0);
+    ensureSlot(graph, childId, "localY", 0);
+    addCandidate(graph, slotId(childId, "localX"), 0, `overlay(${id})`, "normal");
+    addCandidate(graph, slotId(childId, "localY"), 0, `overlay(${id})`, "normal");
+  }
+}
+function applyConnectorRule(_rule, node, graph) {
+  const id = node.id;
+  const fromId = node.props.from;
+  const toId = node.props.to;
+  ensureSlot(graph, id, "resolvedWidth", 0);
+  ensureSlot(graph, id, "resolvedHeight", 0);
+  ensureSlot(graph, id, "localX", 0);
+  ensureSlot(graph, id, "localY", 0);
+  ensureSlot(graph, id, "connectorPath");
+  if (fromId && toId) {
+    ensureSlot(graph, fromId, "localX");
+    ensureSlot(graph, fromId, "localY");
+    ensureSlot(graph, fromId, "resolvedWidth");
+    ensureSlot(graph, fromId, "resolvedHeight");
+    ensureSlot(graph, toId, "localX");
+    ensureSlot(graph, toId, "localY");
+    ensureSlot(graph, toId, "resolvedWidth");
+    ensureSlot(graph, toId, "resolvedHeight");
+    addCandidate(graph, slotId(id, "connectorPath"), 0, `connector(${id})`, "normal");
+  }
+}
+function applyFixedSizeRule(rule, node, graph) {
+  const id = node.id;
+  const kind = node.kind;
+  let width;
+  let height;
+  if (rule.size_from_axis) {
+    const axis = node.props.axis ?? "horizontal";
+    const sizeConfig = rule.size_from_axis[axis];
+    width = sizeConfig?.width ?? 0;
+    height = sizeConfig?.height ?? 0;
+  } else {
+    width = getNumericProp(node, "width", rule.params?.width?.default ?? 0);
+    height = getNumericProp(node, "height", rule.params?.height?.default ?? 0);
+  }
+  ensureSlot(graph, id, "resolvedWidth", width);
+  ensureSlot(graph, id, "resolvedHeight", height);
+  ensureSlot(graph, id, "localX", 0);
+  ensureSlot(graph, id, "localY", 0);
+  const priority = kind === "divider" ? "weak" : "normal";
+  addCandidate(graph, slotId(id, "resolvedWidth"), width, `${kind}(${id})`, priority);
+  addCandidate(graph, slotId(id, "resolvedHeight"), height, `${kind}(${id})`, priority);
+}
+function applyGridRule(rule, node, graph, parentId) {
+  const id = node.id;
+  const gap = getNumericProp(node, "gap", 0);
+  const padding = getNumericProp(node, "padding", 0);
+  const gridConfig = rule.grid;
+  const rowKind = gridConfig.row_kind;
+  const cellKind = gridConfig.cell_kind;
+  registerSizeSlots(node, graph, parentId);
+  ensureSlot(graph, id, "contentWidth");
+  ensureSlot(graph, id, "contentHeight");
+  const rows = (node.children ?? []).filter((c) => c.kind === rowKind);
+  if (rows.length === 0) return;
+  const rowIds = rows.map((r) => r.id);
+  for (const rowId of rowIds) {
+    ensureSlot(graph, rowId, "resolvedWidth");
+    ensureSlot(graph, rowId, "resolvedHeight");
+    ensureSlot(graph, rowId, "localX");
+    ensureSlot(graph, rowId, "localY");
+  }
+  const rowPosOpId = `op.grid.rowPos.${id}`;
+  const rowHeightSlots = rowIds.map((rid) => slotId(rid, "resolvedHeight"));
+  const rowPosOutputs = [
+    ...rowIds.map((rid) => slotId(rid, "localY")),
+    ...rowIds.map((rid) => slotId(rid, "localX")),
+    slotId(id, "contentHeight"),
+    slotId(id, "resolvedHeight")
+  ];
+  for (const rid of rowIds) {
+    addCandidate(graph, slotId(rid, "localY"), void 0, `grid(${id}).rowPos`, "strong", rowPosOpId);
+    addCandidate(graph, slotId(rid, "localX"), void 0, `grid(${id}).rowX`, "normal", rowPosOpId);
+  }
+  addCandidate(graph, slotId(id, "contentHeight"), void 0, `grid(${id}).contentH`, "strong", rowPosOpId);
+  addCandidate(graph, slotId(id, "resolvedHeight"), void 0, `grid(${id}).wrapH`, "normal", rowPosOpId);
+  addOperation(graph, rowPosOpId, "stackPosition", rowHeightSlots, rowPosOutputs, (inputs) => {
+    let y = padding;
+    const yPositions = [];
+    for (let i = 0; i < rowIds.length; i++) {
+      yPositions.push(y);
+      y += (inputs[i] ?? 0) + (i < rowIds.length - 1 ? gap : 0);
+    }
+    const contentH = y - padding;
+    const totalH = contentH + padding * 2;
+    const xPositions = rowIds.map(() => padding);
+    return [...yPositions, ...xPositions, contentH, totalH];
+  });
+  const maxCols = Math.max(...rows.map((r) => (r.children ?? []).filter((c) => c.kind === cellKind).length));
+  const columnCellIds = [];
+  for (let col = 0; col < maxCols; col++) {
+    columnCellIds.push([]);
+  }
+  for (const row of rows) {
+    const cells = (row.children ?? []).filter((c) => c.kind === cellKind);
+    for (let col = 0; col < cells.length && col < maxCols; col++) {
+      columnCellIds[col].push(cells[col].id);
+    }
+  }
+  const cellPaddingMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    for (const cell of (row.children ?? []).filter((c) => c.kind === cellKind)) {
+      cellPaddingMap.set(cell.id, getNumericProp(cell, "padding", 0));
+    }
+  }
+  const colMinWidthSlots = [];
+  for (let col = 0; col < maxCols; col++) {
+    const cellIds = columnCellIds[col];
+    const colMinSlot = `${id}.colMinWidth.${col}`;
+    colMinWidthSlots.push(colMinSlot);
+    ensureSlot(graph, id, `colMinWidth.${col}`);
+    if (cellIds.length < 2) {
+      if (cellIds.length === 1) {
+        const cid = cellIds[0];
+        const p = cellPaddingMap.get(cid) ?? 0;
+        const singleOpId = `op.grid.colMin.${id}.${col}`;
+        ensureSlot(graph, cid, "contentWidth");
+        addCandidate(graph, colMinSlot, void 0, `grid(${id}).colMin[${col}]`, "strong", singleOpId);
+        addOperation(graph, singleOpId, "columnWidthResolve", [slotId(cid, "contentWidth")], [colMinSlot], (inputs) => {
+          return [(inputs[0] ?? 0) + p * 2];
+        });
+      }
+      continue;
+    }
+    const colEqOpId = `op.grid.colMin.${id}.${col}`;
+    const widthInputs = cellIds.map((cid) => {
+      ensureSlot(graph, cid, "contentWidth");
+      return slotId(cid, "contentWidth");
+    });
+    const colPaddings = cellIds.map((cid) => cellPaddingMap.get(cid) ?? 0);
+    addCandidate(graph, colMinSlot, void 0, `grid(${id}).colMin[${col}]`, "strong", colEqOpId);
+    addOperation(graph, colEqOpId, "columnWidthResolve", widthInputs, [colMinSlot], (inputs) => {
+      const desiredWidths = inputs.map((w, i) => (w ?? 0) + colPaddings[i] * 2);
+      return [Math.max(...desiredWidths, 0)];
+    });
+  }
+  if (maxCols > 0) {
+    const wrapWidthOpId = `op.grid.wrapWidth.${id}`;
+    const wrapOutputs = [slotId(id, "contentWidth"), slotId(id, "resolvedWidth")];
+    addCandidate(graph, slotId(id, "contentWidth"), void 0, `grid(${id}).wrapContentW`, "normal", wrapWidthOpId);
+    addCandidate(graph, slotId(id, "resolvedWidth"), void 0, `grid(${id}).wrapW`, "normal", wrapWidthOpId);
+    addOperation(graph, wrapWidthOpId, "resolveSize", colMinWidthSlots, wrapOutputs, (inputs) => {
+      const contentW = inputs.reduce((sum, w) => sum + (w ?? 0), 0) + gap * Math.max(0, inputs.length - 1);
+      return [contentW, contentW + padding * 2];
+    });
+  }
+  const colResolvedWidthSlots = [];
+  if (maxCols > 0) {
+    const colFillOpId = `op.grid.colFill.${id}`;
+    const colFillInputs = [slotId(id, "resolvedWidth"), ...colMinWidthSlots];
+    const colFillOutputs = [];
+    for (let col = 0; col < maxCols; col++) {
+      const colResSlot = `${id}.colResolvedWidth.${col}`;
+      colResolvedWidthSlots.push(colResSlot);
+      ensureSlot(graph, id, `colResolvedWidth.${col}`);
+      colFillOutputs.push(colResSlot);
+      addCandidate(graph, colResSlot, void 0, `grid(${id}).colFill[${col}]`, "strong", colFillOpId);
+    }
+    addOperation(graph, colFillOpId, "columnFill", colFillInputs, colFillOutputs, (inputs) => {
+      const resolvedW = inputs[0] ?? 0;
+      const availableW = resolvedW - padding * 2;
+      const minWidths = inputs.slice(1).map((v) => v ?? 0);
+      const totalMin = minWidths.reduce((s, w) => s + w, 0) + gap * Math.max(0, maxCols - 1);
+      const surplus = Math.max(0, availableW - totalMin);
+      const surplusPerCol = surplus / maxCols;
+      return minWidths.map((mw) => mw + surplusPerCol);
+    });
+  }
+  for (let col = 0; col < maxCols; col++) {
+    const cellIds = columnCellIds[col];
+    if (cellIds.length === 0) continue;
+    const cellWOpId = `op.grid.cellW.${id}.${col}`;
+    const colResSlot = colResolvedWidthSlots[col];
+    const cellWOutputs = cellIds.map((cid) => slotId(cid, "resolvedWidth"));
+    for (const cid of cellIds) {
+      addCandidate(graph, slotId(cid, "resolvedWidth"), void 0, `grid(${id}).cellW[${col}]`, "strong", cellWOpId);
+    }
+    addOperation(graph, cellWOpId, "copy", [colResSlot], cellWOutputs, (inputs) => {
+      return cellIds.map(() => inputs[0] ?? 0);
+    });
+  }
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const cells = (rows[rowIdx].children ?? []).filter((c) => c.kind === cellKind);
+    const cellIds = cells.map((c) => c.id);
+    if (cellIds.length < 2) continue;
+    const rowEqOpId = `op.grid.rowEq.${id}.${rowIdx}`;
+    const heightInputs = cellIds.map((cid) => {
+      ensureSlot(graph, cid, "contentHeight");
+      return slotId(cid, "contentHeight");
+    });
+    const rowEqOutputs = cellIds.map((cid) => slotId(cid, "resolvedHeight"));
+    const rowPaddings = cellIds.map((cid) => cellPaddingMap.get(cid) ?? 0);
+    for (const cid of cellIds) {
+      addCandidate(graph, slotId(cid, "resolvedHeight"), void 0, `grid(${id}).rowEq[${rowIdx}]`, "strong", rowEqOpId);
+    }
+    addOperation(graph, rowEqOpId, "rowHeightResolve", heightInputs, rowEqOutputs, (inputs) => {
+      const desiredHeights = inputs.map((h, i) => (h ?? 0) + rowPaddings[i] * 2);
+      const maxH = Math.max(...desiredHeights, 0);
+      return cellIds.map(() => maxH);
+    });
+  }
+  for (const rowId of rowIds) {
+    const rowWidthOpId = `op.grid.rowWidth.${id}.${rowId}`;
+    const outSid = slotId(rowId, "resolvedWidth");
+    addCandidate(graph, outSid, void 0, `grid(${id}).rowWidth`, "normal", rowWidthOpId);
+    addOperation(graph, rowWidthOpId, "resolveSize", [slotId(id, "resolvedWidth")], [outSid], (inputs) => {
+      return [(inputs[0] ?? 0) - padding * 2];
+    });
+  }
+  for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+    const cells = (rows[rowIdx].children ?? []).filter((c) => c.kind === cellKind);
+    const cellIds = cells.map((c) => c.id);
+    const rowHeightOpId = `op.grid.rowH.${id}.${rowIdx}`;
+    const cellHeightInputs = cellIds.map((cid) => slotId(cid, "resolvedHeight"));
+    const outSid = slotId(rowIds[rowIdx], "resolvedHeight");
+    addCandidate(graph, outSid, void 0, `grid(${id}).rowH`, "normal", rowHeightOpId);
+    addOperation(graph, rowHeightOpId, "max", cellHeightInputs, [outSid], (inputs) => {
+      return [Math.max(...inputs, 0)];
+    });
+  }
+}
+function applyStubRule(node, graph, parentId) {
+  const id = node.id;
+  registerSizeSlots(node, graph, parentId);
+  ensureSlot(graph, id, "contentWidth");
+  ensureSlot(graph, id, "contentHeight");
+}
+var STACK_RULE = layoutRules["stack"];
+function applyLayoutFromRule(kind, node, graph, parentId) {
+  if (STACK_RULE.applies_to && kind in STACK_RULE.applies_to) {
+    const axisConfig = STACK_RULE.applies_to[kind];
+    applyStackRule(STACK_RULE, axisConfig, kind, node, graph, parentId);
+    return;
+  }
+  let rule = layoutRules[kind];
+  if (!rule) {
+    applyStubRule(node, graph, parentId);
+    return;
+  }
+  if (rule.inherits) {
+    const base = layoutRules[rule.inherits];
+    if (base) {
+      rule = { ...base, ...rule };
+    }
+  }
+  switch (rule.type) {
+    case "root":
+      applyRootRule(rule, node, graph);
+      break;
+    case "container":
+      applyContainerRule(rule, node, graph, parentId);
+      break;
+    case "text_measurement":
+      applyTextMeasurementRule(rule, node, graph, parentId);
+      break;
+    case "overlay":
+      applyOverlayRule(rule, node, graph, parentId);
+      break;
+    case "connector":
+      applyConnectorRule(rule, node, graph);
+      break;
+    case "fixed_size":
+      applyFixedSizeRule(rule, node, graph);
+      break;
+    case "grid":
+      applyGridRule(rule, node, graph, parentId);
+      break;
+    default:
+      applyStubRule(node, graph, parentId);
+      break;
+  }
+}
+
+// src/compiler/compiler.ts
+function isParamRef(v) {
+  return typeof v === "object" && v !== null && v.__paramRef === true;
+}
+function isTemplateRef(v) {
+  return typeof v === "object" && v !== null && v.__templateRef === true;
+}
+var TSX_TO_IR = {
+  Document: "document",
+  Group: "group",
+  Box: "box",
+  VStack: "vstack",
+  HStack: "hstack",
+  Overlay: "overlay",
+  Grid: "grid",
+  Flow: "flow",
+  Absolute: "absolute",
+  Spacer: "spacer",
+  Divider: "divider",
+  Text: "text",
+  Label: "label",
+  Image: "image",
+  Icon: "icon",
+  SvgAsset: "svgAsset",
+  Connector: "connector",
+  AlignConstraint: "alignConstraint",
+  EqualizeWidth: "equalizeWidth",
+  EqualizeHeight: "equalizeHeight",
+  MinGap: "minGap",
+  KeepInsideConstraint: "keepInsideConstraint",
+  OrderConstraint: "orderConstraint",
+  Table: "table",
+  Row: "row",
+  Cell: "cell"
+};
+var TEXT_KINDS = /* @__PURE__ */ new Set(["text", "label"]);
+function hasExportModifier(node) {
+  if (!ts.canHaveModifiers(node)) return false;
+  const mods = ts.getModifiers(node);
+  return mods?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function extractParamNames(params) {
+  if (params.length === 0) return /* @__PURE__ */ new Set();
+  const param = params[0];
+  if (!ts.isObjectBindingPattern(param.name)) return null;
+  const names = /* @__PURE__ */ new Set();
+  for (const el of param.name.elements) {
+    if (ts.isIdentifier(el.name)) {
+      names.add(el.name.text);
+    }
+  }
+  return names;
+}
+function findReturnJsx(body) {
+  if (!body) return void 0;
+  for (const stmt of body.statements) {
+    if (ts.isReturnStatement(stmt) && stmt.expression) {
+      let expr = stmt.expression;
+      while (ts.isParenthesizedExpression(expr)) expr = expr.expression;
+      if (ts.isJsxElement(expr) || ts.isJsxSelfClosingElement(expr)) return expr;
+    }
+  }
+  return void 0;
+}
+function evaluateExpression(expr, paramNames) {
+  if (ts.isNumericLiteral(expr)) return Number(expr.text);
+  if (ts.isStringLiteral(expr)) return expr.text;
+  if (ts.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
+  if (expr.kind === ts.SyntaxKind.TrueKeyword) return true;
+  if (expr.kind === ts.SyntaxKind.FalseKeyword) return false;
+  if (ts.isPrefixUnaryExpression(expr) && expr.operator === ts.SyntaxKind.MinusToken) {
+    const operand = evaluateExpression(expr.operand, paramNames);
+    if (typeof operand === "number") return -operand;
+  }
+  if (ts.isArrayLiteralExpression(expr)) {
+    return expr.elements.map((el) => evaluateExpression(el, paramNames));
+  }
+  if (ts.isObjectLiteralExpression(expr)) {
+    const obj = {};
+    for (const prop of expr.properties) {
+      if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+        obj[prop.name.text] = evaluateExpression(prop.initializer, paramNames);
+      }
+    }
+    return obj;
+  }
+  if (paramNames && ts.isIdentifier(expr) && paramNames.has(expr.text)) {
+    return { __paramRef: true, name: expr.text };
+  }
+  if (ts.isTemplateExpression(expr)) {
+    const parts = [];
+    if (expr.head.text) parts.push(expr.head.text);
+    for (const span of expr.templateSpans) {
+      const spanVal = evaluateExpression(span.expression, paramNames);
+      if (isParamRef(spanVal)) {
+        parts.push(spanVal);
+      } else if (spanVal !== void 0) {
+        parts.push(String(spanVal));
+      }
+      if (span.literal.text) parts.push(span.literal.text);
+    }
+    if (parts.every((p) => typeof p === "string")) {
+      return parts.join("");
+    }
+    return { __templateRef: true, parts };
+  }
+  return void 0;
+}
+function extractAttrValue(init, paramNames) {
+  if (!init) return true;
+  if (ts.isStringLiteral(init)) return init.text;
+  if (ts.isJsxExpression(init) && init.expression) {
+    return evaluateExpression(init.expression, paramNames);
+  }
+  return void 0;
+}
+function extractAttributes(attrs, paramNames) {
+  const props = {};
+  for (const attr of attrs.properties) {
+    if (ts.isJsxAttribute(attr) && ts.isIdentifier(attr.name)) {
+      const val = extractAttrValue(attr.initializer, paramNames);
+      if (val !== void 0) {
+        props[attr.name.text] = val;
+      }
+    }
+  }
+  return props;
+}
+function collectTextContent(children) {
+  const parts = [];
+  for (const child of children) {
+    if (ts.isJsxText(child)) {
+      const trimmed = child.text.trim();
+      if (trimmed) parts.push(trimmed);
+    }
+  }
+  return parts.join(" ");
+}
+function collectTextContentForTemplate(children, paramNames) {
+  const parts = [];
+  for (const child of children) {
+    if (ts.isJsxText(child)) {
+      const trimmed = child.text.trim();
+      if (trimmed) parts.push(trimmed);
+    } else if (ts.isJsxExpression(child) && child.expression) {
+      const val = evaluateExpression(child.expression, paramNames);
+      if (isParamRef(val)) {
+        parts.push(val);
+      } else if (val !== void 0) {
+        parts.push(String(val));
+      }
+    }
+  }
+  if (parts.length === 0) return void 0;
+  if (parts.every((p) => typeof p === "string")) {
+    return parts.join(" ");
+  }
+  if (parts.length === 1 && isParamRef(parts[0])) {
+    return parts[0];
+  }
+  return { __templateRef: true, parts };
+}
+function extractComponentDefs(sourceFile, diagnostics, knownComponents) {
+  const defs = /* @__PURE__ */ new Map();
+  const registry = new Map(knownComponents ?? []);
+  for (const stmt of sourceFile.statements) {
+    if (!hasExportModifier(stmt)) continue;
+    if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+      const pNames = extractParamNames(stmt.parameters);
+      if (pNames === null) continue;
+      const jsx = findReturnJsx(stmt.body);
+      if (!jsx) continue;
+      const ctx = {
+        diagnostics,
+        registry,
+        paramNames: pNames,
+        expandingStack: /* @__PURE__ */ new Set()
+      };
+      const template = compileElement(jsx, ctx);
+      if (template) {
+        const def = { name: stmt.name.text, paramNames: pNames, template };
+        defs.set(stmt.name.text, def);
+        registry.set(stmt.name.text, def);
+      }
+    }
+    if (ts.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (!ts.isIdentifier(decl.name) || !decl.initializer) continue;
+        if (!ts.isArrowFunction(decl.initializer)) continue;
+        const name = decl.name.text;
+        const arrow = decl.initializer;
+        const pNames = extractParamNames(arrow.parameters);
+        if (pNames === null) continue;
+        let jsx;
+        if (ts.isBlock(arrow.body)) {
+          jsx = findReturnJsx(arrow.body);
+        } else {
+          let expr = arrow.body;
+          while (ts.isParenthesizedExpression(expr)) expr = expr.expression;
+          if (ts.isJsxElement(expr) || ts.isJsxSelfClosingElement(expr)) jsx = expr;
+        }
+        if (!jsx) continue;
+        const ctx = {
+          diagnostics,
+          registry,
+          paramNames: pNames,
+          expandingStack: /* @__PURE__ */ new Set()
+        };
+        const template = compileElement(jsx, ctx);
+        if (template) {
+          const def = { name, paramNames: pNames, template };
+          defs.set(name, def);
+          registry.set(name, def);
+        }
+      }
+    }
+  }
+  return defs;
+}
+function expandComponentTag(tagName, props, childNodes, ctx) {
+  if (ctx.expandingStack.has(tagName)) {
+    ctx.diagnostics.push({
+      level: "error",
+      message: `Circular component reference: ${tagName}`,
+      path: tagName
+    });
+    return null;
+  }
+  const def = ctx.registry.get(tagName);
+  if (!def) return null;
+  ctx.expandingStack.add(tagName);
+  const compiledChildren = [];
+  if (childNodes) {
+    for (const child of childNodes) {
+      if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+        const compiled = compileElement(child, ctx);
+        if (compiled) compiledChildren.push(compiled);
+      }
+    }
+  }
+  const id = props["id"];
+  const idIsParam = def.paramNames.has("id");
+  const paramValues = {};
+  const extraProps = {};
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "id" && !idIsParam) continue;
+    if (def.paramNames.has(key)) {
+      paramValues[key] = value;
+    } else {
+      extraProps[key] = value;
+    }
+  }
+  const expanded = deepCloneAndSubstitute(def.template, paramValues, compiledChildren);
+  Object.assign(expanded.props, extraProps);
+  if (id && !idIsParam) expanded.id = id;
+  ctx.expandingStack.delete(tagName);
+  return expanded;
+}
+function deepCloneAndSubstitute(node, paramValues, compiledChildren) {
+  const cloned = { kind: node.kind, props: {} };
+  if (node.id) cloned.id = node.id;
+  for (const [key, value] of Object.entries(node.props)) {
+    if (key === "__childrenSlot") continue;
+    if (key === "__idParam") {
+      const resolved = substituteValue(value, paramValues);
+      if (typeof resolved === "string") {
+        cloned.id = resolved;
+      } else if (isParamRef(resolved) || isTemplateRef(resolved)) {
+        cloned.props["__idParam"] = resolved;
+      }
+      continue;
+    }
+    cloned.props[key] = substituteValue(value, paramValues);
+  }
+  if (node.children) {
+    const newChildren = [];
+    for (const child of node.children) {
+      if (child.props.__childrenSlot === true) {
+        newChildren.push(...compiledChildren);
+      } else {
+        newChildren.push(deepCloneAndSubstitute(child, paramValues, compiledChildren));
+      }
+    }
+    if (newChildren.length > 0) cloned.children = newChildren;
+  }
+  return cloned;
+}
+function substituteValue(value, paramValues) {
+  if (isParamRef(value)) {
+    return paramValues[value.name];
+  }
+  if (isTemplateRef(value)) {
+    const newParts = [];
+    for (const part of value.parts) {
+      if (isParamRef(part)) {
+        const resolved = paramValues[part.name];
+        if (resolved === void 0) {
+        } else if (typeof resolved === "string") {
+          newParts.push(resolved);
+        } else if (isParamRef(resolved)) {
+          newParts.push(resolved);
+        } else if (isTemplateRef(resolved)) {
+          newParts.push(...resolved.parts);
+        } else {
+          newParts.push(String(resolved));
+        }
+      } else {
+        newParts.push(part);
+      }
+    }
+    const allStrings = newParts.every((p) => typeof p === "string");
+    if (allStrings) {
+      return newParts.join("");
+    }
+    return { __templateRef: true, parts: newParts };
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => substituteValue(item, paramValues));
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = substituteValue(v, paramValues);
+    }
+    return result;
+  }
+  return value;
+}
+function resolveImports(sourceFile, resolveImport, diagnostics, fromFile, fileCache) {
+  const allDefs = /* @__PURE__ */ new Map();
+  const cache = fileCache ?? /* @__PURE__ */ new Map();
+  for (const stmt of sourceFile.statements) {
+    if (!ts.isImportDeclaration(stmt)) continue;
+    if (!ts.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const specifier = stmt.moduleSpecifier.text;
+    const importSource = resolveImport(specifier, fromFile);
+    if (!importSource) continue;
+    const cacheKey = importSource;
+    let defs;
+    if (cache.has(cacheKey)) {
+      defs = cache.get(cacheKey);
+    } else {
+      cache.set(cacheKey, /* @__PURE__ */ new Map());
+      const importedFile = ts.createSourceFile(
+        specifier,
+        importSource,
+        ts.ScriptTarget.Latest,
+        true,
+        ts.ScriptKind.TSX
+      );
+      const transitiveDefs = resolveImports(importedFile, resolveImport, diagnostics, specifier, cache);
+      for (const [k, v] of transitiveDefs) allDefs.set(k, v);
+      defs = extractComponentDefs(importedFile, diagnostics, allDefs);
+      cache.set(cacheKey, defs);
+    }
+    if (stmt.importClause?.namedBindings && ts.isNamedImports(stmt.importClause.namedBindings)) {
+      for (const imp of stmt.importClause.namedBindings.elements) {
+        const importedName = (imp.propertyName ?? imp.name).text;
+        const localName = imp.name.text;
+        const def = defs.get(importedName);
+        if (def) {
+          allDefs.set(localName, { ...def, name: localName });
+        }
+      }
+    }
+  }
+  return allDefs;
+}
+function compileElement(node, ctx) {
+  let tagName;
+  let props;
+  let childNodes;
+  if (ts.isJsxSelfClosingElement(node)) {
+    tagName = node.tagName.getText();
+    props = extractAttributes(node.attributes, ctx.paramNames);
+  } else {
+    tagName = node.openingElement.tagName.getText();
+    props = extractAttributes(node.openingElement.attributes, ctx.paramNames);
+    childNodes = node.children;
+  }
+  const kind = TSX_TO_IR[tagName];
+  if (!kind) {
+    if (ctx.registry.has(tagName)) {
+      return expandComponentTag(tagName, props, childNodes, ctx);
+    }
+    ctx.diagnostics.push({
+      level: "warning",
+      message: `Unknown TSX element <${tagName}>`,
+      path: tagName
+    });
+    return null;
+  }
+  const irProps = {};
+  const rawId = props["id"];
+  delete props["id"];
+  const allowed = getAllowedProps(kind);
+  if (allowed) {
+    for (const key of Object.keys(props)) {
+      if (!allowed.has(key)) {
+        ctx.diagnostics.push({
+          level: "error",
+          message: `Unknown property "${key}" on <${tagName}>. Allowed: ${[...allowed].filter((k) => k !== "id" && k !== "geometry").sort().join(", ")}`,
+          path: tagName
+        });
+      }
+    }
+  }
+  Object.assign(irProps, props);
+  const irNode = { kind, props: irProps };
+  if (isParamRef(rawId) || isTemplateRef(rawId)) {
+    irProps["__idParam"] = rawId;
+  } else if (typeof rawId === "string") {
+    irNode.id = rawId;
+  }
+  if (childNodes) {
+    if (TEXT_KINDS.has(kind)) {
+      if (ctx.paramNames) {
+        const text = collectTextContentForTemplate(childNodes, ctx.paramNames);
+        if (text !== void 0) irNode.props["text"] = text;
+      } else {
+        const text = collectTextContent(childNodes);
+        if (text) irNode.props["text"] = text;
+      }
+    }
+    const children = [];
+    for (const child of childNodes) {
+      if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+        const compiled = compileElement(child, ctx);
+        if (compiled) children.push(compiled);
+      } else if (ctx.paramNames && ts.isJsxExpression(child) && child.expression && ts.isIdentifier(child.expression) && child.expression.text === "children" && ctx.paramNames.has("children")) {
+        children.push({ kind: "group", props: { __childrenSlot: true } });
+      }
+    }
+    if (children.length > 0) irNode.children = children;
+  }
+  return irNode;
+}
+function findRootJsxElement(sourceFile) {
+  let result;
+  function visit(node) {
+    if (result) return;
+    if (ts.isFunctionDeclaration(node) && hasExportModifier(node)) return;
+    if (ts.isVariableStatement(node) && hasExportModifier(node)) return;
+    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+      result = node;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  return result;
+}
+function compileDrawTsx(source, options) {
+  const sourceFile = ts.createSourceFile(
+    "input.tsx",
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TSX
+  );
+  const diagnostics = [];
+  const registry = new Map(options?.components);
+  const inlineDefs = extractComponentDefs(sourceFile, diagnostics);
+  for (const [name, def] of inlineDefs) {
+    registry.set(name, def);
+  }
+  if (options?.resolveImport) {
+    const importDefs = resolveImports(
+      sourceFile,
+      options.resolveImport,
+      diagnostics
+    );
+    for (const [name, def] of importDefs) {
+      registry.set(name, def);
+    }
+  }
+  const root = findRootJsxElement(sourceFile);
+  if (!root) {
+    diagnostics.push({
+      level: "error",
+      message: "No JSX element found in source",
+      path: "root"
+    });
+    return {
+      ir: { kind: "document", props: {} },
+      diagnostics
+    };
+  }
+  const ctx = {
+    diagnostics,
+    registry,
+    expandingStack: /* @__PURE__ */ new Set()
+  };
+  const ir = compileElement(root, ctx);
+  const compiledIr = ir ?? { kind: "document", props: {} };
+  validateUniqueIds(compiledIr, diagnostics);
+  return { ir: compiledIr, diagnostics };
+}
+function validateUniqueIds(root, diagnostics) {
+  const seen = /* @__PURE__ */ new Map();
+  collectNodeIds(root, seen, "root");
+  for (const [id, paths] of seen) {
+    if (paths.length > 1) {
+      diagnostics.push({
+        level: "error",
+        message: `Duplicate id '${id}' after component expansion (${paths.length} occurrences). Component children must use derived IDs (e.g. \`\${id}-child\`).`,
+        path: paths[0]
+      });
+    }
+  }
+}
+function collectNodeIds(node, seen, path) {
+  if (node.id) {
+    const paths = seen.get(node.id) ?? [];
+    paths.push(path);
+    seen.set(node.id, paths);
+  }
+  if (node.children) {
+    for (let i = 0; i < node.children.length; i++) {
+      collectNodeIds(node.children[i], seen, `${path}.children[${i}]`);
+    }
+  }
+}
+
+// src/design/index.ts
+import { z as z2 } from "zod";
+import { load as load2 } from "js-yaml";
+var TokenEntrySchema = z2.object({
+  $type: z2.enum(["color", "dimension", "fontFamily", "fontWeight", "number", "shadow", "string"]),
+  $value: z2.string()
+});
+var TokenIRSchema = z2.lazy(
+  () => z2.record(z2.string(), z2.union([TokenEntrySchema, TokenIRSchema]))
+);
+var ThemeIRSchema = z2.object({
+  defaults: z2.record(z2.string(), z2.record(z2.string(), z2.unknown())),
+  variants: z2.record(
+    z2.string(),
+    z2.record(z2.string(), z2.record(z2.string(), z2.unknown()))
+  )
+});
+function parseTokens(yaml) {
+  const raw = load2(yaml);
+  return TokenIRSchema.parse(raw);
+}
+function parseTheme(yaml) {
+  const raw = load2(yaml);
+  return ThemeIRSchema.parse(raw);
+}
+function resolveTokenRef(ref, tokens) {
+  const path = ref.replace(/^\{|\}$/g, "");
+  const parts = path.split(".");
+  let current = tokens;
+  for (const part of parts) {
+    if (isTokenEntry(current)) {
+      throw new Error(`Cannot traverse into token entry at '${part}' in ref '${ref}'`);
+    }
+    const next = current[part];
+    if (next === void 0) {
+      throw new Error(`Token path '${path}' not found at segment '${part}'`);
+    }
+    current = next;
+  }
+  if (isTokenEntry(current)) {
+    return current.$value;
+  }
+  throw new Error(`Token ref '${ref}' does not resolve to a token entry (found group)`);
+}
+function isTokenEntry(value) {
+  return "$type" in value && "$value" in value;
+}
+
+// src/design/defaults.ts
+var TOKENS_YAML = `draw:
+  font-family:
+    $type: fontFamily
+    $value: "system-ui, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif"
+  primary:
+    $type: color
+    $value: "#2563eb"
+  surface:
+    $type: color
+    $value: "#ffffff"
+  border:
+    $type: color
+    $value: "#e5e7eb"
+  text:
+    $type: color
+    $value: "#111827"
+  on-primary:
+    $type: color
+    $value: "#ffffff"
+  connector-default:
+    $type: color
+    $value: "#6b7280"
+  space:
+    node-padding:
+      $type: dimension
+      $value: "12px"
+    node-radius:
+      $type: dimension
+      $value: "8px"
+    connector-width:
+      $type: dimension
+      $value: "1.5px"
+    font-label:
+      $type: dimension
+      $value: "12px"
+    font-node:
+      $type: dimension
+      $value: "14px"
+`;
+var THEME_YAML = `defaults:
+  Document:
+    fontFamily: "{draw.font-family}"
+  Box:
+    fill: "{draw.surface}"
+    stroke: "{draw.border}"
+    strokeWidth: 1
+    radius: "{draw.space.node-radius}"
+    padding: "{draw.space.node-padding}"
+  Text:
+    foreground: "{draw.text}"
+    fontSize: "{draw.space.font-node}"
+  Connector:
+    stroke: "{draw.connector-default}"
+    strokeWidth: "{draw.space.connector-width}"
+    route: orthogonal
+    endArrow: arrow
+  Label:
+    fontSize: "{draw.space.font-label}"
+    foreground: "{draw.text}"
+
+variants:
+  Box:
+    primary:
+      fill: "{draw.primary}"
+      foreground: "{draw.on-primary}"
+    muted:
+      fill: "{draw.surface}"
+      stroke: "{draw.border}"
+      opacity: 0.6
+  Connector:
+    dashed:
+      strokeStyle: dashed
+      opacity: 0.7
+    highlighted:
+      stroke: "{draw.primary}"
+      strokeWidth: 2
+`;
+var _cachedTokens;
+var _cachedTheme;
+function defaultTokens() {
+  if (!_cachedTokens) _cachedTokens = parseTokens(TOKENS_YAML);
+  return _cachedTokens;
+}
+function defaultTheme() {
+  if (!_cachedTheme) _cachedTheme = parseTheme(THEME_YAML);
+  return _cachedTheme;
+}
+
+// src/normalizer/index.ts
+function kindToPascal(kind) {
+  return kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+function normalize(ir, options) {
+  const diagnostics = [];
+  const result = structuredClone(ir);
+  const kindCounters = /* @__PURE__ */ new Map();
+  assignAutoIds(result, kindCounters);
+  checkDuplicateIds(result, diagnostics);
+  applyThemeAndVariants(result, options.theme);
+  resolveAllTokens(result, options.tokens, diagnostics, "root");
+  const geometryRegistry = buildGeometryRegistry(result, diagnostics);
+  resolveGeometryReferences(result, geometryRegistry, diagnostics);
+  return { ir: result, diagnostics, geometryRegistry };
+}
+function assignAutoIds(node, counters) {
+  if (!node.id) {
+    const count = (counters.get(node.kind) ?? 0) + 1;
+    counters.set(node.kind, count);
+    node.id = `${node.kind}_${count}`;
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      assignAutoIds(child, counters);
+    }
+  }
+}
+function checkDuplicateIds(root, diagnostics) {
+  const idLocations = /* @__PURE__ */ new Map();
+  collectIds(root, idLocations, "root");
+  for (const [id, paths] of idLocations) {
+    if (paths.length > 1) {
+      diagnostics.push({
+        level: "error",
+        message: `Duplicate id '${id}' found at: ${paths.join(", ")}`,
+        path: paths[0]
+      });
+    }
+  }
+}
+function collectIds(node, idLocations, path) {
+  if (node.id) {
+    const paths = idLocations.get(node.id) ?? [];
+    paths.push(path);
+    idLocations.set(node.id, paths);
+  }
+  if (node.children) {
+    for (let i = 0; i < node.children.length; i++) {
+      collectIds(node.children[i], idLocations, `${path}.children[${i}]`);
+    }
+  }
+}
+function applyThemeAndVariants(node, theme) {
+  const pascalKind = kindToPascal(node.kind);
+  const explicitKeys = new Set(Object.keys(node.props));
+  const defaults = theme.defaults[pascalKind];
+  if (defaults) {
+    for (const [key, value] of Object.entries(defaults)) {
+      if (!explicitKeys.has(key)) {
+        node.props[key] = value;
+      }
+    }
+  }
+  const variantName = explicitKeys.has("variant") ? node.props.variant : void 0;
+  if (variantName) {
+    const variantDefs = theme.variants[pascalKind]?.[variantName];
+    if (variantDefs) {
+      for (const [key, value] of Object.entries(variantDefs)) {
+        if (!explicitKeys.has(key)) {
+          node.props[key] = value;
+        }
+      }
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      applyThemeAndVariants(child, theme);
+    }
+  }
+}
+function isTokenRef(value) {
+  return typeof value === "string" && /^\{.+\}$/.test(value);
+}
+var DIMENSION_RE = /^(-?\d+(?:\.\d+)?)\s*(?:px|rem|em|pt|dp)$/;
+function coerceDimension(value) {
+  const m = DIMENSION_RE.exec(value);
+  if (m) return parseFloat(m[1]);
+  return value;
+}
+function resolveValue(value, tokens, diagnostics, propPath) {
+  if (isTokenRef(value)) {
+    try {
+      const resolved = resolveTokenRef(value, tokens);
+      return coerceDimension(resolved);
+    } catch (err) {
+      diagnostics.push({
+        level: "error",
+        message: `Failed to resolve token '${value}': ${err.message}`,
+        path: propPath
+      });
+      return value;
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item, i) => resolveValue(item, tokens, diagnostics, `${propPath}[${i}]`)
+    );
+  }
+  return value;
+}
+function resolveAllTokens(node, tokens, diagnostics, path) {
+  for (const [key, value] of Object.entries(node.props)) {
+    node.props[key] = resolveValue(value, tokens, diagnostics, `${path}.props.${key}`);
+  }
+  if (node.children) {
+    for (let i = 0; i < node.children.length; i++) {
+      resolveAllTokens(node.children[i], tokens, diagnostics, `${path}.children[${i}]`);
+    }
+  }
+}
+var STANDARD_ROLES = ["layout", "align", "connect", "hit", "measure"];
+var DEFAULT_GEOMETRY = {
+  layout: "self",
+  align: "self",
+  connect: "self",
+  hit: "self",
+  measure: "self"
+};
+function buildGeometryRegistry(root, diagnostics) {
+  const registry = /* @__PURE__ */ new Map();
+  collectGeometryProps(root, registry, diagnostics);
+  return registry;
+}
+function collectGeometryProps(node, registry, diagnostics) {
+  if (node.id && node.props.geometry) {
+    const geom = node.props.geometry;
+    if (typeof geom === "object" && geom !== null && !Array.isArray(geom)) {
+      const roleMap = { ...DEFAULT_GEOMETRY };
+      for (const [role, target] of Object.entries(geom)) {
+        if (!STANDARD_ROLES.includes(role)) {
+          diagnostics.push({
+            level: "warning",
+            message: `Unknown geometry role '${role}' on node '${node.id}'`,
+            path: node.id
+          });
+        }
+        if (typeof target === "string") {
+          roleMap[role] = target;
+        }
+      }
+      registry.set(node.id, roleMap);
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      collectGeometryProps(child, registry, diagnostics);
+    }
+  }
+}
+function parseGeometryRef(ref) {
+  const colonIdx = ref.indexOf(":");
+  if (colonIdx === -1) return { nodeId: ref };
+  return { nodeId: ref.substring(0, colonIdx), role: ref.substring(colonIdx + 1) };
+}
+function resolveWithRole(nodeId, role, registry) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = nodeId;
+  while (!visited.has(current)) {
+    visited.add(current);
+    const roleMap = registry.get(current);
+    if (!roleMap) return current;
+    const target = roleMap[role];
+    if (!target || target === "self") return current;
+    current = target;
+  }
+  return current;
+}
+function resolveGeometryRef(ref, implicitRole, registry) {
+  const { nodeId, role } = parseGeometryRef(ref);
+  const effectiveRole = role ?? implicitRole;
+  if (!effectiveRole) return nodeId;
+  return resolveWithRole(nodeId, effectiveRole, registry);
+}
+function resolveGeometryReferences(node, registry, diagnostics) {
+  const kind = node.kind;
+  if (kind === "alignConstraint") {
+    const targets = node.props.targets;
+    if (targets) {
+      const alignRefs = {};
+      for (const t of targets) {
+        const resolved = resolveGeometryRef(t, "align", registry);
+        if (resolved !== t) alignRefs[t] = resolved;
+      }
+      if (Object.keys(alignRefs).length > 0) {
+        node.props.alignRefs = alignRefs;
+      }
+    }
+    const anchor = node.props.anchor;
+    if (anchor) {
+      const resolved = resolveGeometryRef(anchor, "align", registry);
+      if (resolved !== anchor) {
+        node.props.alignRefs = { ...node.props.alignRefs ?? {}, [anchor]: resolved };
+      }
+    }
+  }
+  if (kind === "connector") {
+    const from = node.props.from;
+    if (from) {
+      node.props.from = resolveGeometryRef(from, "connect", registry);
+    }
+    const to = node.props.to;
+    if (to) {
+      node.props.to = resolveGeometryRef(to, "connect", registry);
+    }
+  }
+  if (kind === "equalizeWidth" || kind === "equalizeHeight" || kind === "minGap" || kind === "keepInsideConstraint" || kind === "orderConstraint") {
+    const targets = node.props.targets;
+    if (targets) {
+      node.props.targets = targets.map(
+        (t) => resolveGeometryRef(t, void 0, registry)
+      );
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      resolveGeometryReferences(child, registry, diagnostics);
+    }
+  }
+}
+
+// src/renderer/shapes.ts
+var STROKE_DASHARRAY = {
+  dashed: "6 4",
+  dotted: "2 3"
+};
+function styleAttrs(styles) {
+  const parts = [];
+  if (styles.fill != null) parts.push(`fill="${esc(styles.fill)}"`);
+  else parts.push('fill="none"');
+  if (styles.stroke != null) parts.push(`stroke="${esc(styles.stroke)}"`);
+  if (styles.strokeWidth != null) parts.push(`stroke-width="${styles.strokeWidth}"`);
+  if (styles.strokeStyle != null && styles.strokeStyle !== "solid") {
+    const da = STROKE_DASHARRAY[String(styles.strokeStyle)];
+    if (da) parts.push(`stroke-dasharray="${da}"`);
+  }
+  if (styles.opacity != null) parts.push(`opacity="${styles.opacity}"`);
+  return parts.join(" ");
+}
+function esc(v) {
+  return String(v).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function pts(coords) {
+  return coords.map(([px, py]) => `${px},${py}`).join(" ");
+}
+function renderRect(r, sa) {
+  return `<rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" ${sa}/>`;
+}
+function renderRoundedRect(r, styles, sa) {
+  const rx = styles.radius != null ? Number(styles.radius) : 8;
+  return `<rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" rx="${rx}" ${sa}/>`;
+}
+function renderCircle(r, sa) {
+  const radius = r.width / 2;
+  return `<circle cx="${r.x + radius}" cy="${r.y + radius}" r="${radius}" ${sa}/>`;
+}
+function renderEllipse(r, sa) {
+  const rx = r.width / 2;
+  const ry = r.height / 2;
+  return `<ellipse cx="${r.x + rx}" cy="${r.y + ry}" rx="${rx}" ry="${ry}" ${sa}/>`;
+}
+function renderDiamond(r, sa) {
+  const cx = r.x + r.width / 2;
+  const cy = r.y + r.height / 2;
+  const points = [
+    [cx, r.y],
+    [r.x + r.width, cy],
+    [cx, r.y + r.height],
+    [r.x, cy]
+  ];
+  return `<polygon points="${pts(points)}" ${sa}/>`;
+}
+function renderParallelogram(r, sa) {
+  const skew = r.width * 0.2;
+  const points = [
+    [r.x + skew, r.y],
+    [r.x + r.width, r.y],
+    [r.x + r.width - skew, r.y + r.height],
+    [r.x, r.y + r.height]
+  ];
+  return `<polygon points="${pts(points)}" ${sa}/>`;
+}
+function renderCapsule(r, sa) {
+  const rx = Math.min(r.width, r.height) / 2;
+  return `<rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" rx="${rx}" ${sa}/>`;
+}
+function renderCylinder(r, sa) {
+  const ellipseH = Math.min(r.height * 0.2, 20);
+  const ry = ellipseH / 2;
+  const x = r.x;
+  const y = r.y;
+  const w = r.width;
+  const h = r.height;
+  const rx = w / 2;
+  const topArc = `M ${x},${y + ry} A ${rx},${ry} 0 0,1 ${x + w},${y + ry}`;
+  const rightSide = `L ${x + w},${y + h - ry}`;
+  const bottomArc = `A ${rx},${ry} 0 0,1 ${x},${y + h - ry}`;
+  const leftSide = `L ${x},${y + ry}`;
+  const topEllipseBack = `M ${x},${y + ry} A ${rx},${ry} 0 0,0 ${x + w},${y + ry}`;
+  return `<path d="${topArc} ${rightSide} ${bottomArc} ${leftSide}" ${sa}/><path d="${topEllipseBack}" ${styles_stroke_only(sa)}/>`;
+}
+function styles_stroke_only(sa) {
+  return sa.replace(/fill="[^"]*"/, 'fill="none"');
+}
+function renderHexagon(r, sa) {
+  const cx = r.x + r.width / 2;
+  const cy = r.y + r.height / 2;
+  const inset = r.width * 0.25;
+  const points = [
+    [r.x + inset, r.y],
+    [r.x + r.width - inset, r.y],
+    [r.x + r.width, cy],
+    [r.x + r.width - inset, r.y + r.height],
+    [r.x + inset, r.y + r.height],
+    [r.x, cy]
+  ];
+  return `<polygon points="${pts(points)}" ${sa}/>`;
+}
+function renderTriangle(r, sa) {
+  const points = [
+    [r.x + r.width / 2, r.y],
+    [r.x + r.width, r.y + r.height],
+    [r.x, r.y + r.height]
+  ];
+  return `<polygon points="${pts(points)}" ${sa}/>`;
+}
+var SHAPE_RENDERERS = {
+  rect: (r, _s, sa) => renderRect(r, sa),
+  roundedRect: (r, s, sa) => renderRoundedRect(r, s, sa),
+  circle: (r, _s, sa) => renderCircle(r, sa),
+  ellipse: (r, _s, sa) => renderEllipse(r, sa),
+  diamond: (r, _s, sa) => renderDiamond(r, sa),
+  parallelogram: (r, _s, sa) => renderParallelogram(r, sa),
+  capsule: (r, _s, sa) => renderCapsule(r, sa),
+  cylinder: (r, _s, sa) => renderCylinder(r, sa),
+  hexagon: (r, _s, sa) => renderHexagon(r, sa),
+  triangle: (r, _s, sa) => renderTriangle(r, sa)
+};
+function renderShape(shape, rect, styles) {
+  const sa = styleAttrs(styles);
+  const renderer = SHAPE_RENDERERS[shape] ?? SHAPE_RENDERERS.rect;
+  return renderer(rect, styles, sa);
+}
+
+// src/renderer/connectors.ts
+var BASE_MARKER_SIZE = 7;
+var BASE_MARKER_HALF = BASE_MARKER_SIZE / 2;
+var MARKER_TEMPLATES = [
+  { type: "arrow", path: `M 0,0 L ${BASE_MARKER_SIZE},${BASE_MARKER_HALF} L 0,${BASE_MARKER_SIZE}`, fill: false, shape: "polygon" },
+  { type: "filledArrow", path: `M 0,0 L ${BASE_MARKER_SIZE},${BASE_MARKER_HALF} L 0,${BASE_MARKER_SIZE} Z`, fill: true, shape: "polygon" },
+  { type: "diamond", path: `M 0,${BASE_MARKER_HALF} L ${BASE_MARKER_HALF},0 L ${BASE_MARKER_SIZE},${BASE_MARKER_HALF} L ${BASE_MARKER_HALF},${BASE_MARKER_SIZE} Z`, fill: false, shape: "polygon" },
+  { type: "filledDiamond", path: `M 0,${BASE_MARKER_HALF} L ${BASE_MARKER_HALF},0 L ${BASE_MARKER_SIZE},${BASE_MARKER_HALF} L ${BASE_MARKER_HALF},${BASE_MARKER_SIZE} Z`, fill: true, shape: "polygon" },
+  { type: "circle", path: "", fill: false, shape: "circle" },
+  { type: "filledCircle", path: "", fill: true, shape: "circle" }
+];
+function renderMarkerDef(def, size) {
+  const half = size / 2;
+  const scale = size / BASE_MARKER_SIZE;
+  const common = `id="${def.id}" markerWidth="${size}" markerHeight="${size}" refX="${size}" refY="${half}" orient="auto-start-reverse"`;
+  if (def.shape === "circle") {
+    const r = half * 0.8;
+    const fillAttr2 = def.fill ? `fill="${def.color}"` : `fill="none" stroke="${def.color}" stroke-width="1"`;
+    return `<marker ${common}><circle cx="${half}" cy="${half}" r="${r}" ${fillAttr2}/></marker>`;
+  }
+  const fillAttr = def.fill ? `fill="${def.color}"` : `fill="none" stroke="${def.color}" stroke-width="1"`;
+  if (scale === 1) {
+    return `<marker ${common}><path d="${def.path}" ${fillAttr}/></marker>`;
+  }
+  return `<marker ${common}><path d="${def.path}" ${fillAttr} transform="scale(${scale})"/></marker>`;
+}
+function renderArrowMarkers() {
+  return `<defs>
+</defs>`;
+}
+var dynamicMarkerRegistry = /* @__PURE__ */ new Map();
+function resetDynamicMarkers() {
+  dynamicMarkerRegistry.clear();
+}
+function getDynamicMarkerDefs() {
+  if (dynamicMarkerRegistry.size === 0) return "";
+  return Array.from(dynamicMarkerRegistry.values()).join("\n");
+}
+function ensureColoredMarker(arrowType, arrowSize, color) {
+  const colorKey = color.replace(/[^a-zA-Z0-9]/g, "");
+  const sizeKey = arrowSize === 1 ? "" : `-s${arrowSize}`;
+  const id = `marker-${arrowType}-${colorKey}${sizeKey}`;
+  if (!dynamicMarkerRegistry.has(id)) {
+    const template = MARKER_TEMPLATES.find((t) => t.type === arrowType);
+    if (template) {
+      const size = BASE_MARKER_SIZE * arrowSize;
+      const def = renderMarkerDef(
+        { id, path: template.path, fill: template.fill, shape: template.shape, color },
+        size
+      );
+      dynamicMarkerRegistry.set(id, def);
+    }
+  }
+  return id;
+}
+var STROKE_DASHARRAY2 = {
+  dashed: "6 4",
+  dotted: "2 3"
+};
+function renderConnector(node) {
+  const d = node.connectorPath ?? "";
+  const styles = node.styles;
+  const strokeColor = styles.stroke != null ? String(styles.stroke) : "#6b7280";
+  const parts = [`d="${d}"`];
+  parts.push('fill="none"');
+  parts.push(`stroke="${strokeColor}"`);
+  if (styles.strokeWidth != null) parts.push(`stroke-width="${styles.strokeWidth}"`);
+  else parts.push('stroke-width="1.5"');
+  if (styles.strokeDasharray != null) {
+    parts.push(`stroke-dasharray="${styles.strokeDasharray}"`);
+  } else if (styles.strokeStyle != null && styles.strokeStyle !== "solid") {
+    const da = STROKE_DASHARRAY2[String(styles.strokeStyle)];
+    if (da) parts.push(`stroke-dasharray="${da}"`);
+  }
+  if (styles.opacity != null) parts.push(`opacity="${styles.opacity}"`);
+  const arrowSize = styles.arrowSize != null ? Number(styles.arrowSize) : 1;
+  const startArrow = styles.startArrow != null ? String(styles.startArrow) : "none";
+  const endArrow = styles.endArrow != null ? String(styles.endArrow) : "arrow";
+  if (startArrow !== "none") {
+    const markerId = ensureColoredMarker(startArrow, arrowSize, strokeColor);
+    parts.push(`marker-start="url(#${markerId})"`);
+  }
+  if (endArrow !== "none") {
+    const markerId = ensureColoredMarker(endArrow, arrowSize, strokeColor);
+    parts.push(`marker-end="url(#${markerId})"`);
+  }
+  return `<path ${parts.join(" ")}/>`;
+}
+
+// src/renderer/text.ts
+function escXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderText(node) {
+  const lines = node.textLines ?? [];
+  if (lines.length === 0) return "";
+  const styles = node.styles;
+  const anchor = node.textAnchor ?? "middle";
+  const tx = node.textX ?? node.worldRect.x + node.worldRect.width / 2;
+  const fontSize = styles.fontSize != null ? Number(styles.fontSize) : 14;
+  const lineHeight = fontSize * 1.3;
+  const startY = node.textBaseline ?? node.worldRect.y + (node.worldRect.height - lineHeight * lines.length) / 2 + fontSize;
+  const attrs = [`text-anchor="${anchor}"`];
+  if (styles.foreground != null) attrs.push(`fill="${styles.foreground}"`);
+  else attrs.push('fill="#000"');
+  if (styles.fontSize != null) attrs.push(`font-size="${styles.fontSize}"`);
+  if (styles.fontWeight != null && styles.fontWeight !== "regular") {
+    attrs.push(`font-weight="${styles.fontWeight}"`);
+  }
+  if (styles.fontFamily != null) attrs.push(`font-family="${styles.fontFamily}"`);
+  const tspans = lines.map((line, i) => {
+    const dy = i === 0 ? 0 : lineHeight;
+    return `<tspan x="${tx}" dy="${dy}">${escXml(line)}</tspan>`;
+  });
+  return `<text x="${tx}" y="${startY}" ${attrs.join(" ")}>${tspans.join("")}</text>`;
+}
+
+// src/renderer/svg.ts
+var clipIdCounter = 0;
+var LAYOUT_KINDS = /* @__PURE__ */ new Set([
+  "document",
+  "vstack",
+  "hstack",
+  "group",
+  "overlay",
+  "grid",
+  "flow",
+  "absolute",
+  "row"
+]);
+var CONSTRAINT_KINDS = /* @__PURE__ */ new Set([
+  "alignConstraint",
+  "equalizeWidth",
+  "equalizeHeight",
+  "minGap",
+  "keepInsideConstraint",
+  "orderConstraint"
+]);
+var FIT_TO_PAR = {
+  contain: "xMidYMid meet",
+  cover: "xMidYMid slice",
+  fill: "none",
+  none: "xMidYMid meet"
+};
+function renderConnectorLabel(node) {
+  const text = renderText(node);
+  if (!text) return "";
+  const r = node.worldRect;
+  const bg = node.styles.background != null ? String(node.styles.background) : "#ffffff";
+  const pad = 2;
+  const rect = bg === "none" ? "" : `<rect x="${r.x - pad}" y="${r.y - pad}" width="${r.width + pad * 2}" height="${r.height + pad * 2}" fill="${bg}"/>`;
+  return `<g id="${escId(node.id)}">${rect}${text}</g>`;
+}
+function renderImage(node) {
+  const r = node.worldRect;
+  const src = node.styles.src;
+  if (!src) {
+    return `<g id="${escId(node.id)}"><rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" fill="#eee" stroke="#ccc" stroke-width="1" stroke-dasharray="4 2"/></g>`;
+  }
+  const fit = String(node.styles.fit ?? "contain");
+  const par = FIT_TO_PAR[fit] ?? FIT_TO_PAR.contain;
+  return `<g id="${escId(node.id)}"><image href="${escAttr(src)}" x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" preserveAspectRatio="${par}"/></g>`;
+}
+function renderIcon(node, registry) {
+  const r = node.worldRect;
+  const name = node.styles.name;
+  if (!name) {
+    return `<g id="${escId(node.id)}"><rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" fill="#eee" stroke="#ccc" stroke-width="1" stroke-dasharray="4 2"/></g>`;
+  }
+  const svgContent = registry?.resolveQualified(name);
+  if (svgContent) {
+    return renderInlineSvg(node.id, r, svgContent);
+  }
+  const fg = node.styles.foreground ?? "#666";
+  const fontSize = Math.min(r.width, r.height) * 0.35;
+  const shortLabel = name.includes(":") ? name.split(":")[1] : name;
+  const cx = r.x + r.width / 2;
+  const cy = r.y + r.height / 2;
+  return [
+    `<g id="${escId(node.id)}">`,
+    `<rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" fill="#f5f5f5" stroke="#ddd" stroke-width="1" rx="4"/>`,
+    `<text x="${cx}" y="${cy}" text-anchor="middle" dominant-baseline="central" font-size="${fontSize}" fill="${fg}">${escText(shortLabel)}</text>`,
+    `</g>`
+  ].join("");
+}
+function renderSvgAsset(node) {
+  const r = node.worldRect;
+  const src = node.styles.src;
+  if (!src) {
+    return `<g id="${escId(node.id)}"><rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" fill="#eee" stroke="#ccc" stroke-width="1" stroke-dasharray="4 2"/></g>`;
+  }
+  return `<g id="${escId(node.id)}"><image href="${escAttr(src)}" x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" preserveAspectRatio="xMidYMid meet"/></g>`;
+}
+function renderInlineSvg(id, r, svgContent) {
+  const viewBoxMatch = svgContent.match(/viewBox="([^"]+)"/);
+  const viewBox = viewBoxMatch ? viewBoxMatch[1] : `0 0 ${r.width} ${r.height}`;
+  const inner = svgContent.replace(/<svg[^>]*>/, "").replace(/<\/svg>\s*$/, "");
+  return [
+    `<g id="${escId(id)}">`,
+    `<svg x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" viewBox="${viewBox}">`,
+    inner,
+    `</svg>`,
+    `</g>`
+  ].join("");
+}
+function escAttr(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var iconRegistry;
+function renderNode(node) {
+  const parts = [];
+  if (CONSTRAINT_KINDS.has(node.kind)) {
+    return "";
+  }
+  if (node.kind === "spacer") {
+    return "";
+  }
+  if (LAYOUT_KINDS.has(node.kind)) {
+    if (node.styles.background != null) {
+      parts.push(renderShape("rect", node.worldRect, { fill: node.styles.background }));
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        if (node.kind === "row" && child.kind === "cell" && node.styles.fill != null && child.styles.fill == null) {
+          child.styles.fill = node.styles.fill;
+        }
+        const childSvg = renderNode(child);
+        if (childSvg) parts.push(childSvg);
+      }
+    }
+    if (parts.length === 0) return "";
+    return `<g id="${escId(node.id)}">${parts.join("")}</g>`;
+  }
+  if (node.kind === "table") {
+    const r = node.worldRect;
+    const rx = Number(node.styles.borderRadius ?? 6);
+    const borderStroke = String(node.styles.stroke ?? "#d1d5db");
+    const borderSw = Number(node.styles.strokeWidth ?? 1);
+    const tableFill = String(node.styles.background ?? "white");
+    const clipId = `table-clip-${++clipIdCounter}`;
+    const childParts = [];
+    if (node.children) {
+      for (const child of node.children) {
+        const childSvg = renderNode(child);
+        if (childSvg) childParts.push(childSvg);
+      }
+    }
+    const clipDef = `<defs><clipPath id="${clipId}"><rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" rx="${rx}" ry="${rx}"/></clipPath></defs>`;
+    const bg = `<rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" rx="${rx}" ry="${rx}" fill="${tableFill}"/>`;
+    const clipped = `<g clip-path="url(#${clipId})">${childParts.join("")}</g>`;
+    const border = `<rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" rx="${rx}" ry="${rx}" fill="none" stroke="${borderStroke}" stroke-width="${borderSw}"/>`;
+    return `<g id="${escId(node.id)}">${clipDef}${bg}${clipped}${border}</g>`;
+  }
+  if (node.kind === "box") {
+    const shape = node.styles.shape != null ? String(node.styles.shape) : "rect";
+    parts.push(renderShape(shape, node.worldRect, node.styles));
+    if (node.children) {
+      for (const child of node.children) {
+        const childSvg = renderNode(child);
+        if (childSvg) parts.push(childSvg);
+      }
+    }
+    return `<g id="${escId(node.id)}">${parts.join("")}</g>`;
+  }
+  if (node.kind === "text" || node.kind === "label") {
+    const textSvg = renderText(node);
+    if (!textSvg) return "";
+    return `<g id="${escId(node.id)}">${textSvg}</g>`;
+  }
+  if (node.kind === "connector") {
+    const connSvg = renderConnector(node);
+    const labelSvg = (node.children ?? []).filter((c) => c.kind === "label" || c.kind === "text").map(renderConnectorLabel).join("");
+    return `<g id="${escId(node.id)}">${connSvg}${labelSvg}</g>`;
+  }
+  if (node.kind === "divider") {
+    const r = node.worldRect;
+    const stroke = node.styles.stroke ?? "#ccc";
+    const sw = node.styles.strokeWidth ?? 1;
+    const line = r.width >= r.height ? `<line x1="${r.x}" y1="${r.y}" x2="${r.x + r.width}" y2="${r.y}" stroke="${stroke}" stroke-width="${sw}"/>` : `<line x1="${r.x}" y1="${r.y}" x2="${r.x}" y2="${r.y + r.height}" stroke="${stroke}" stroke-width="${sw}"/>`;
+    return `<g id="${escId(node.id)}">${line}</g>`;
+  }
+  if (node.kind === "cell") {
+    const r = node.worldRect;
+    const cellParts = [];
+    const cellFill = node.styles.fill ?? "none";
+    const cellStroke = node.styles.stroke ?? "#e5e7eb";
+    const cellSw = node.styles.strokeWidth ?? 0.5;
+    cellParts.push(`<rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" fill="${cellFill}" stroke="${cellStroke}" stroke-width="${cellSw}"/>`);
+    if (node.children) {
+      for (const child of node.children) {
+        const childSvg = renderNode(child);
+        if (childSvg) cellParts.push(childSvg);
+      }
+    }
+    return `<g id="${escId(node.id)}">${cellParts.join("")}</g>`;
+  }
+  if (node.kind === "image") {
+    return renderImage(node);
+  }
+  if (node.kind === "icon") {
+    return renderIcon(node, iconRegistry);
+  }
+  if (node.kind === "svgAsset") {
+    return renderSvgAsset(node);
+  }
+  return "";
+}
+function escId(id) {
+  return id.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderSvg(artifact, options) {
+  clipIdCounter = 0;
+  resetDynamicMarkers();
+  iconRegistry = options?.iconRegistry;
+  const vb = artifact.viewBox;
+  const body = [];
+  if (artifact.background != null) {
+    body.push(`<rect x="${vb.x}" y="${vb.y}" width="${vb.width}" height="${vb.height}" fill="${artifact.background}"/>`);
+  }
+  for (const node of artifact.nodes) {
+    const nodeSvg = renderNode(node);
+    if (nodeSvg) body.push(nodeSvg);
+  }
+  const dynamicDefs = getDynamicMarkerDefs();
+  const defaultDefs = renderArrowMarkers();
+  const defs = dynamicDefs ? defaultDefs.replace("</defs>", dynamicDefs + "\n</defs>") : defaultDefs;
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${vb.x} ${vb.y} ${vb.width} ${vb.height}" width="${vb.width}" height="${vb.height}"${artifact.fontFamily ? ` font-family="${artifact.fontFamily}"` : ""}>`,
+    defs,
+    body.join("\n"),
+    "</svg>"
+  ].join("\n");
+}
+
+// src/icons/registry.ts
+function createIconRegistry() {
+  const packs = /* @__PURE__ */ new Map();
+  return {
+    register(pack) {
+      packs.set(pack.provider, pack);
+    },
+    resolve(provider, name) {
+      return packs.get(provider)?.resolve(name);
+    },
+    resolveQualified(qualifiedName) {
+      const colonIdx = qualifiedName.indexOf(":");
+      if (colonIdx < 0) return void 0;
+      const provider = qualifiedName.slice(0, colonIdx);
+      const name = qualifiedName.slice(colonIdx + 1);
+      return packs.get(provider)?.resolve(name);
+    }
+  };
+}
+
+// src/icons/aws-icon-pack.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+var SHORT_NAME_MAP = {
+  // Architecture service icons
+  lambda: "architecture-service/AWSLambda",
+  dynamodb: "architecture-service/AmazonDynamoDB",
+  apigateway: "architecture-service/AmazonAPIGateway",
+  s3: "architecture-service/AmazonSimpleStorageService",
+  ec2: "architecture-service/AmazonEC2",
+  rds: "architecture-service/AmazonRDS",
+  sqs: "architecture-service/AmazonSQS",
+  sns: "architecture-service/AmazonSNS",
+  cloudfront: "architecture-service/AmazonCloudFront",
+  ecs: "architecture-service/AmazonElasticContainerService",
+  eks: "architecture-service/AmazonElasticKubernetesService",
+  fargate: "architecture-service/AWSFargate",
+  elasticloadbalancing: "architecture-service/ElasticLoadBalancing",
+  cloudwatch: "architecture-service/AmazonCloudWatch",
+  iam: "architecture-service/AWSIdentityandAccessManagement",
+  route53: "architecture-service/AmazonRoute53",
+  cloudformation: "architecture-service/AWSCloudFormation",
+  stepfunctions: "architecture-service/AWSStepFunctions",
+  kinesis: "architecture-service/AmazonKinesis",
+  elasticache: "architecture-service/AmazonElastiCache",
+  secretsmanager: "architecture-service/AWSSecretsManager",
+  codepipeline: "architecture-service/AWSCodePipeline",
+  codebuild: "architecture-service/AWSCodeBuild",
+  cognito: "architecture-service/AmazonCognito",
+  eventbridge: "architecture-service/AmazonEventBridge",
+  waf: "architecture-service/AWSWAF",
+  aurora: "architecture-service/AmazonAurora",
+  redshift: "architecture-service/AmazonRedshift",
+  glue: "architecture-service/AWSGlue",
+  dms: "architecture-service/AWSDatabaseMigrationService",
+  directconnect: "architecture-service/AWSDirectConnect",
+  natgateway: "architecture-service/AmazonVPCLattice",
+  // Architecture group icons
+  "vpc-group": "architecture-group/VirtualprivatecloudVPC",
+  "region-group": "architecture-group/Region",
+  "subnet-public": "architecture-group/Publicsubnet",
+  "subnet-private": "architecture-group/Privatesubnet",
+  "auto-scaling-group": "architecture-group/AutoScalinggroup",
+  "aws-cloud": "architecture-group/AWSCloud",
+  "aws-account": "architecture-group/AWSAccount"
+};
+var svgCache = /* @__PURE__ */ new Map();
+function tryResolveAwsIconsPath() {
+  try {
+    const esmRequire = createRequire(import.meta.url);
+    const resolved = esmRequire.resolve("aws-icons/package.json");
+    return resolved.replace(/package\.json$/, "icons/");
+  } catch {
+    return void 0;
+  }
+}
+var awsIconsBasePath = null;
+function getBasePath() {
+  if (awsIconsBasePath === null) {
+    awsIconsBasePath = tryResolveAwsIconsPath();
+  }
+  return awsIconsBasePath ?? void 0;
+}
+function loadSvg(relativePath) {
+  const cached = svgCache.get(relativePath);
+  if (cached) return cached;
+  const base = getBasePath();
+  if (!base) return void 0;
+  try {
+    const svg = readFileSync(base + relativePath + ".svg", "utf-8");
+    svgCache.set(relativePath, svg);
+    return svg;
+  } catch {
+    return void 0;
+  }
+}
+function createAwsIconPack() {
+  return {
+    provider: "aws",
+    resolve(name) {
+      const mapped = SHORT_NAME_MAP[name];
+      if (mapped) return loadSvg(mapped);
+      return loadSvg("architecture-service/" + name);
+    },
+    list() {
+      return Object.keys(SHORT_NAME_MAP);
+    }
+  };
+}
+
+// src/graph/resolver.ts
+var PRIORITY_RANK = {
+  required: 4,
+  strong: 3,
+  normal: 2,
+  weak: 1
+};
+function resolveSlot(candidates, policy) {
+  const resolved = candidates.filter((c) => c.value !== void 0);
+  if (resolved.length === 0) return void 0;
+  switch (policy) {
+    case "requiredAllEqual":
+      return resolveRequiredAllEqual(resolved);
+    case "highestPriority":
+      return resolveHighestPriority(resolved);
+    case "max":
+      return Math.max(...resolved.map((c) => c.value));
+    case "sum":
+      return resolved.reduce((acc, c) => acc + c.value, 0);
+  }
+}
+function resolveRequiredAllEqual(candidates) {
+  const requiredCandidates = candidates.filter((c) => c.priority === "required");
+  if (requiredCandidates.length === 0) {
+    return resolveHighestPriority(candidates);
+  }
+  const firstValue = requiredCandidates[0].value;
+  for (let i = 1; i < requiredCandidates.length; i++) {
+    if (requiredCandidates[i].value !== firstValue) {
+      throw new Error(
+        `Required conflict: slot has conflicting required values ${firstValue} (from ${requiredCandidates[0].source}) vs ${requiredCandidates[i].value} (from ${requiredCandidates[i].source})`
+      );
+    }
+  }
+  return firstValue;
+}
+function resolveHighestPriority(candidates) {
+  if (candidates.length === 0) return void 0;
+  let best = candidates[0];
+  for (let i = 1; i < candidates.length; i++) {
+    if (PRIORITY_RANK[candidates[i].priority] > PRIORITY_RANK[best.priority]) {
+      best = candidates[i];
+    }
+  }
+  return best.value;
+}
+
+// src/graph/fragments.ts
+var ALL_KINDS = [
+  "document",
+  "vstack",
+  "hstack",
+  "box",
+  "text",
+  "label",
+  "connector",
+  "group",
+  "overlay",
+  "grid",
+  "flow",
+  "absolute",
+  "spacer",
+  "divider",
+  "image",
+  "icon",
+  "svgAsset",
+  "table",
+  "row",
+  "cell",
+  "alignConstraint",
+  "equalizeWidth",
+  "equalizeHeight",
+  "orderConstraint",
+  "minGap",
+  "keepInsideConstraint"
+];
+function createFragmentFactory(kind) {
+  return (node, graph, parentId) => {
+    if (!applyConstraintFromRule(kind, node, graph)) {
+      applyLayoutFromRule(kind, node, graph, parentId);
+    }
+  };
+}
+var FRAGMENT_MAP = {};
+for (const kind of ALL_KINDS) {
+  FRAGMENT_MAP[kind] = createFragmentFactory(kind);
+}
+
+// src/graph/evaluator.ts
+function createGraph() {
+  return {
+    slots: /* @__PURE__ */ new Map(),
+    operations: /* @__PURE__ */ new Map(),
+    candidates: [],
+    candidatesBySlot: /* @__PURE__ */ new Map(),
+    candidatesByOperation: /* @__PURE__ */ new Map(),
+    resolvers: /* @__PURE__ */ new Map(),
+    dependencies: [],
+    parentMap: /* @__PURE__ */ new Map(),
+    nodeKindMap: /* @__PURE__ */ new Map(),
+    childrenOrderMap: /* @__PURE__ */ new Map(),
+    diagnostics: []
+  };
+}
+function evaluate(graph, ir) {
+  const diagnostics = [];
+  buildFragments(graph, ir, void 0);
+  diagnostics.push(...graph.diagnostics);
+  runEvaluation(graph, diagnostics);
+  const artifact = collectArtifact(graph, ir);
+  return { artifact, diagnostics };
+}
+function buildFragments(graph, node, parentId) {
+  const factory = FRAGMENT_MAP[node.kind];
+  if (factory) {
+    factory(node, graph, parentId);
+  }
+  const nodeId = node.id;
+  if (nodeId && !isConstraintKind(node.kind)) {
+    graph.nodeKindMap.set(nodeId, node.kind);
+    if (parentId) {
+      graph.parentMap.set(nodeId, parentId);
+    }
+    addWorldCoordOps(graph, nodeId, parentId);
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      buildFragments(graph, child, node.id);
+    }
+  }
+}
+function addWorldCoordOps(graph, nodeId, parentId) {
+  ensureSlot(graph, nodeId, "worldX");
+  ensureSlot(graph, nodeId, "worldY");
+  if (!parentId) {
+    addCandidate(graph, slotId(nodeId, "worldX"), 0, `root.worldX`, "weak");
+    addCandidate(graph, slotId(nodeId, "worldY"), 0, `root.worldY`, "weak");
+    return;
+  }
+  ensureSlot(graph, parentId, "worldX");
+  ensureSlot(graph, parentId, "worldY");
+  ensureSlot(graph, nodeId, "localX");
+  ensureSlot(graph, nodeId, "localY");
+  const wxOpId = `op.worldX.${nodeId}`;
+  addCandidate(graph, slotId(nodeId, "worldX"), void 0, `worldCoord(${nodeId})`, "weak", wxOpId);
+  addOperation(graph, wxOpId, "add", [slotId(parentId, "worldX"), slotId(nodeId, "localX")], [slotId(nodeId, "worldX")], (inputs) => {
+    return [(inputs[0] ?? 0) + (inputs[1] ?? 0)];
+  });
+  const wyOpId = `op.worldY.${nodeId}`;
+  addCandidate(graph, slotId(nodeId, "worldY"), void 0, `worldCoord(${nodeId})`, "weak", wyOpId);
+  addOperation(graph, wyOpId, "add", [slotId(parentId, "worldY"), slotId(nodeId, "localY")], [slotId(nodeId, "worldY")], (inputs) => {
+    return [(inputs[0] ?? 0) + (inputs[1] ?? 0)];
+  });
+}
+function runEvaluation(graph, diagnostics) {
+  const order = topologicalSort(graph, diagnostics);
+  resolveAllSlots(graph, diagnostics);
+  function executeOp(opId) {
+    const op = graph.operations.get(opId);
+    if (!op) return;
+    const inputs = op.inputs.map((sid) => {
+      const slot = graph.slots.get(sid);
+      return slot?.value ?? 0;
+    });
+    const outputs = op.compute(inputs);
+    const opCandidates = graph.candidatesByOperation.get(opId);
+    if (opCandidates) {
+      for (let i = 0; i < op.outputs.length && i < outputs.length; i++) {
+        const targetSlotId = op.outputs[i];
+        const val = outputs[i];
+        for (const c of opCandidates) {
+          if (c.targetSlotId === targetSlotId) {
+            c.value = val;
+          }
+        }
+      }
+    }
+    resolveOutputSlots(graph, op.outputs, diagnostics);
+  }
+  for (const opId of order) {
+    executeOp(opId);
+  }
+  for (let pass = 0; pass < 2; pass++) {
+    for (const opId of order) {
+      const op = graph.operations.get(opId);
+      if (!op) continue;
+      if (op.op === "suffixShiftDelta" || op.op === "stackCompose" || op.op === "add") {
+        executeOp(opId);
+      }
+    }
+  }
+  resolveAllSlots(graph, diagnostics);
+}
+function resolveAllSlots(graph, diagnostics) {
+  for (const [sid, slot] of graph.slots) {
+    const candidates = graph.candidatesBySlot.get(sid);
+    if (!candidates || candidates.length === 0) continue;
+    const resolver = graph.resolvers.get(sid);
+    const policy = resolver?.policy ?? "highestPriority";
+    try {
+      const value = resolveSlot(candidates, policy);
+      if (value !== void 0) {
+        slot.value = value;
+      }
+    } catch (err) {
+      diagnostics.push({
+        level: "error",
+        message: err.message,
+        path: sid
+      });
+    }
+  }
+}
+function resolveOutputSlots(graph, outputSlots, diagnostics) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const sid of outputSlots) {
+    if (seen.has(sid)) continue;
+    seen.add(sid);
+    const slot = graph.slots.get(sid);
+    if (!slot) continue;
+    const candidates = graph.candidatesBySlot.get(sid);
+    if (!candidates || candidates.length === 0) continue;
+    const resolver = graph.resolvers.get(sid);
+    const policy = resolver?.policy ?? "highestPriority";
+    try {
+      const value = resolveSlot(candidates, policy);
+      if (value !== void 0) {
+        slot.value = value;
+      }
+    } catch (err) {
+      diagnostics.push({
+        level: "error",
+        message: err.message,
+        path: sid
+      });
+    }
+  }
+}
+function topologicalSort(graph, diagnostics) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adj = /* @__PURE__ */ new Map();
+  const edgeSet = /* @__PURE__ */ new Set();
+  for (const opId of graph.operations.keys()) {
+    inDegree.set(opId, 0);
+    adj.set(opId, []);
+  }
+  const slotToOps = /* @__PURE__ */ new Map();
+  for (const dep of graph.dependencies) {
+    const ops = slotToOps.get(dep.fromSlotId) ?? [];
+    ops.push(dep.toOperationId);
+    slotToOps.set(dep.fromSlotId, ops);
+  }
+  function addEdge(fromOpId, toOpId) {
+    if (fromOpId === toOpId) return;
+    if (!graph.operations.has(toOpId)) return;
+    const key = `${fromOpId}\0${toOpId}`;
+    if (edgeSet.has(key)) return;
+    edgeSet.add(key);
+    adj.get(fromOpId).push(toOpId);
+    inDegree.set(toOpId, (inDegree.get(toOpId) ?? 0) + 1);
+  }
+  for (const op of graph.operations.values()) {
+    for (const outputSlotId of op.outputs) {
+      const dependentOps = slotToOps.get(outputSlotId);
+      if (dependentOps) {
+        for (const depOpId of dependentOps) {
+          addEdge(op.id, depOpId);
+        }
+      }
+    }
+  }
+  for (const candidate of graph.candidates) {
+    if (candidate.operationId) {
+      const dependentOps = slotToOps.get(candidate.targetSlotId);
+      if (dependentOps) {
+        for (const depOpId of dependentOps) {
+          addEdge(candidate.operationId, depOpId);
+        }
+      }
+    }
+  }
+  const queue = [];
+  for (const [opId, deg] of inDegree) {
+    if (deg === 0) queue.push(opId);
+  }
+  let head = 0;
+  const result = [];
+  while (head < queue.length) {
+    const opId = queue[head++];
+    result.push(opId);
+    for (const next of adj.get(opId) ?? []) {
+      const newDeg = (inDegree.get(next) ?? 1) - 1;
+      inDegree.set(next, newDeg);
+      if (newDeg === 0) {
+        queue.push(next);
+      }
+    }
+  }
+  if (result.length < graph.operations.size) {
+    let dfs2 = function(node) {
+      visited.add(node);
+      stack.add(node);
+      for (const next of adj.get(node) ?? []) {
+        if (!unSet.has(next)) continue;
+        if (stack.has(next)) {
+          cyclePath = [next];
+          let cur = node;
+          while (cur !== next) {
+            cyclePath.unshift(cur);
+            cur = parent.get(cur);
+          }
+          cyclePath.unshift(next);
+          return true;
+        }
+        if (!visited.has(next)) {
+          parent.set(next, node);
+          if (dfs2(next)) return true;
+        }
+      }
+      stack.delete(node);
+      return false;
+    };
+    var dfs = dfs2;
+    const scheduled = new Set(result);
+    const unscheduled = [...graph.operations.keys()].filter((id) => !scheduled.has(id));
+    const unSet = new Set(unscheduled);
+    let cyclePath = [];
+    const visited = /* @__PURE__ */ new Set();
+    const stack = /* @__PURE__ */ new Set();
+    const parent = /* @__PURE__ */ new Map();
+    for (const start of unscheduled) {
+      if (!visited.has(start)) {
+        if (dfs2(start)) break;
+      }
+    }
+    diagnostics.push({
+      level: "warning",
+      message: `Cycle detected: ${unscheduled.length} ops stuck. Path: ${cyclePath.join(" \u2192 ")}`,
+      path: "graph"
+    });
+  }
+  return result;
+}
+function collectArtifact(graph, ir) {
+  const explicitWidth = ir.props.width;
+  const explicitHeight = ir.props.height;
+  const nodes = collectNodesWithOffset(graph, ir, 0, 0);
+  fixConnectorPaths(nodes, graph, ir);
+  let vbWidth;
+  let vbHeight;
+  if (explicitWidth != null && explicitHeight != null) {
+    vbWidth = explicitWidth;
+    vbHeight = explicitHeight;
+  } else {
+    const bounds = computeContentBounds(nodes);
+    const padding = typeof ir.props.padding === "number" ? ir.props.padding : 0;
+    vbWidth = explicitWidth ?? bounds.maxX + padding;
+    vbHeight = explicitHeight ?? bounds.maxY + padding;
+  }
+  const viewBox = { x: 0, y: 0, width: vbWidth, height: vbHeight };
+  const background = typeof ir.props.background === "string" ? ir.props.background : void 0;
+  const fontFamily = typeof ir.props.fontFamily === "string" ? ir.props.fontFamily : void 0;
+  return { viewBox, nodes, background, fontFamily };
+}
+function computeContentBounds(nodes) {
+  let maxX = 0;
+  let maxY = 0;
+  for (const node of nodes) {
+    const r = node.worldRect;
+    maxX = Math.max(maxX, r.x + r.width);
+    maxY = Math.max(maxY, r.y + r.height);
+    if (node.children) {
+      const childBounds = computeContentBounds(node.children);
+      maxX = Math.max(maxX, childBounds.maxX);
+      maxY = Math.max(maxY, childBounds.maxY);
+    }
+  }
+  return { maxX, maxY };
+}
+function collectNodesWithOffset(graph, ir, parentWorldX, parentWorldY) {
+  const results = [];
+  if (ir.children) {
+    for (const child of ir.children) {
+      const node = buildResolvedNode(graph, child, parentWorldX, parentWorldY);
+      if (node) results.push(node);
+    }
+  }
+  return results;
+}
+function buildResolvedNode(graph, ir, parentWorldX, parentWorldY) {
+  const id = ir.id;
+  const kind = ir.kind;
+  if (kind === "alignConstraint" || kind === "equalizeWidth" || kind === "equalizeHeight" || kind === "minGap" || kind === "keepInsideConstraint" || kind === "orderConstraint") {
+    return null;
+  }
+  const width = getSlotValue(graph, id, "resolvedWidth") ?? 0;
+  const height = getSlotValue(graph, id, "resolvedHeight") ?? 0;
+  const x = getSlotValue(graph, id, "localX") ?? 0;
+  const y = getSlotValue(graph, id, "localY") ?? 0;
+  const rect = { x, y, width, height };
+  const worldRect = {
+    x: x + parentWorldX,
+    y: y + parentWorldY,
+    width,
+    height
+  };
+  const styles = {};
+  for (const [key, value] of Object.entries(ir.props)) {
+    if (typeof value === "string" || typeof value === "number") {
+      styles[key] = value;
+    }
+  }
+  const resolved = {
+    id,
+    kind,
+    rect,
+    worldRect,
+    styles
+  };
+  if (kind === "text" || kind === "label") {
+    const text = ir.props.text;
+    if (text) {
+      resolved.textLines = [text];
+    }
+    const textBaselineVal = getSlotValue(graph, id, "textBaseline");
+    const textXVal = getSlotValue(graph, id, "textX");
+    const textAnchorVal = getSlotValue(graph, id, "textAnchor");
+    if (textBaselineVal !== void 0) {
+      resolved.textBaseline = worldRect.y + textBaselineVal;
+    }
+    if (textXVal !== void 0) {
+      resolved.textX = worldRect.x + textXVal;
+    }
+    if (textAnchorVal !== void 0) {
+      switch (textAnchorVal) {
+        case 0:
+          resolved.textAnchor = "start";
+          break;
+        case 2:
+          resolved.textAnchor = "end";
+          break;
+        default:
+          resolved.textAnchor = "middle";
+          break;
+      }
+    }
+  }
+  if (ir.children && ir.children.length > 0) {
+    const children = [];
+    for (const child of ir.children) {
+      const childNode = buildResolvedNode(graph, child, worldRect.x, worldRect.y);
+      if (childNode) children.push(childNode);
+    }
+    if (children.length > 0) {
+      resolved.children = children;
+    }
+  }
+  return resolved;
+}
+function fixConnectorPaths(nodes, _graph, ir) {
+  const worldRectMap = /* @__PURE__ */ new Map();
+  collectWorldRects(nodes, worldRectMap);
+  const connectorInfos = [];
+  for (const node of nodes) {
+    if (node.kind !== "connector") continue;
+    const irNode = findIrNode(ir, node.id);
+    if (!irNode) continue;
+    const fromId = irNode.props.from;
+    const toId = irNode.props.to;
+    if (!fromId || !toId) continue;
+    const fromRect = worldRectMap.get(fromId);
+    const toRect = worldRectMap.get(toId);
+    if (!fromRect || !toRect) continue;
+    const fromAnchor = irNode.props.fromAnchor ?? "auto";
+    const toAnchor = irNode.props.toAnchor ?? "auto";
+    const fromEdge = resolveEdge(fromAnchor, fromRect, toRect);
+    const toEdge = resolveEdge(toAnchor, toRect, fromRect);
+    connectorInfos.push({ node, irNode, fromId, toId, fromAnchor, toAnchor, fromEdge, toEdge });
+  }
+  const edgeGroups = /* @__PURE__ */ new Map();
+  for (const info of connectorInfos) {
+    const fromKey = `${info.fromId}:${info.fromEdge}`;
+    const toKey = `${info.toId}:${info.toEdge}`;
+    if (!edgeGroups.has(fromKey)) edgeGroups.set(fromKey, []);
+    edgeGroups.get(fromKey).push({
+      nodeId: info.fromId,
+      edge: info.fromEdge,
+      anchor: info.fromAnchor,
+      connectorId: info.node.id,
+      role: "from"
+    });
+    if (!edgeGroups.has(toKey)) edgeGroups.set(toKey, []);
+    edgeGroups.get(toKey).push({
+      nodeId: info.toId,
+      edge: info.toEdge,
+      anchor: info.toAnchor,
+      connectorId: info.node.id,
+      role: "to"
+    });
+  }
+  const endpointPositions = /* @__PURE__ */ new Map();
+  for (const [_key, endpoints] of edgeGroups) {
+    endpoints.sort((a, b) => {
+      const aInfo = connectorInfos.find((c) => c.node.id === a.connectorId);
+      const bInfo = connectorInfos.find((c) => c.node.id === b.connectorId);
+      const aOtherId = a.role === "from" ? aInfo.toId : aInfo.fromId;
+      const bOtherId = b.role === "from" ? bInfo.toId : bInfo.fromId;
+      const aOther = worldRectMap.get(aOtherId);
+      const bOther = worldRectMap.get(bOtherId);
+      if (a.edge === "top" || a.edge === "bottom") {
+        return aOther.x + aOther.width / 2 - (bOther.x + bOther.width / 2);
+      }
+      return aOther.y + aOther.height / 2 - (bOther.y + bOther.height / 2);
+    });
+    const n = endpoints.length;
+    for (let i = 0; i < n; i++) {
+      const ep = endpoints[i];
+      const rect = worldRectMap.get(ep.nodeId);
+      const t = (i + 1) / (n + 1);
+      const pos = edgePoint(rect, ep.edge, t);
+      const posKey = `${ep.connectorId}:${ep.role}`;
+      endpointPositions.set(posKey, pos);
+    }
+  }
+  for (const info of connectorInfos) {
+    const from = endpointPositions.get(`${info.node.id}:from`);
+    const to = endpointPositions.get(`${info.node.id}:to`);
+    const route = info.irNode.props.route ?? "straight";
+    if (route === "orthogonal") {
+      const cr = Number(info.irNode.props.cornerRadius ?? 0);
+      info.node.connectorPath = buildOrthogonalPath(from, to, info.fromEdge, info.toEdge, cr, worldRectMap.get(info.fromId), worldRectMap.get(info.toId));
+    } else if (route === "curved") {
+      const curvature = Number(info.irNode.props.curvature ?? 0.33);
+      info.node.connectorPath = buildCurvedPath(from, to, info.fromEdge, info.toEdge, curvature);
+    } else {
+      info.node.connectorPath = `M ${from.x} ${from.y} L ${to.x} ${to.y}`;
+    }
+    positionConnectorLabels(info.node, from, to);
+  }
+}
+function positionConnectorLabels(connector, from, to) {
+  const labels = (connector.children ?? []).filter((c) => c.kind === "label" || c.kind === "text");
+  if (labels.length === 0) return;
+  const midX = (from.x + to.x) / 2;
+  const midY = (from.y + to.y) / 2;
+  for (const label of labels) {
+    const { width, height } = label.worldRect;
+    const newX = midX - width / 2;
+    const newY = midY - height / 2;
+    const dx = newX - label.worldRect.x;
+    const dy = newY - label.worldRect.y;
+    label.worldRect.x = newX;
+    label.worldRect.y = newY;
+    if (label.textX != null) label.textX += dx;
+    if (label.textBaseline != null) label.textBaseline += dy;
+  }
+}
+var ORTHO_MARGIN = 20;
+function edgeNormal(edge) {
+  switch (edge) {
+    case "top":
+      return { dx: 0, dy: -1 };
+    case "bottom":
+      return { dx: 0, dy: 1 };
+    case "left":
+      return { dx: -1, dy: 0 };
+    case "right":
+      return { dx: 1, dy: 0 };
+  }
+}
+function isHorizontalEdge(edge) {
+  return edge === "top" || edge === "bottom";
+}
+function buildOrthogonalPath(from, to, fromEdge, toEdge, cornerRadius, fromRect, toRect) {
+  const waypoints = computeOrthogonalWaypoints(from, to, fromEdge, toEdge, fromRect, toRect);
+  return waypointsToPath(waypoints, cornerRadius);
+}
+function computeOrthogonalWaypoints(from, to, fromEdge, toEdge, fromRect, toRect) {
+  const pts2 = [from];
+  const fromH = isHorizontalEdge(fromEdge);
+  const toH = isHorizontalEdge(toEdge);
+  const fn = edgeNormal(fromEdge);
+  const tn = edgeNormal(toEdge);
+  if (fromEdge === toEdge) {
+    const offset = ORTHO_MARGIN;
+    if (fromH) {
+      const outY = fn.dy > 0 ? Math.max(fromRect.y + fromRect.height, toRect.y + toRect.height) + offset : Math.min(fromRect.y, toRect.y) - offset;
+      pts2.push({ x: from.x, y: outY });
+      pts2.push({ x: to.x, y: outY });
+    } else {
+      const outX = fn.dx > 0 ? Math.max(fromRect.x + fromRect.width, toRect.x + toRect.width) + offset : Math.min(fromRect.x, toRect.x) - offset;
+      pts2.push({ x: outX, y: from.y });
+      pts2.push({ x: outX, y: to.y });
+    }
+  } else if (fromH === toH) {
+    if (fromH) {
+      const midY = (from.y + to.y) / 2;
+      pts2.push({ x: from.x, y: midY });
+      pts2.push({ x: to.x, y: midY });
+    } else {
+      const midX = (from.x + to.x) / 2;
+      pts2.push({ x: midX, y: from.y });
+      pts2.push({ x: midX, y: to.y });
+    }
+  } else {
+    if (fromH) {
+      pts2.push({ x: from.x, y: to.y + tn.dy * 0 });
+      if (Math.abs(from.x - to.x) > 0.1) {
+        pts2.push({ x: from.x, y: to.y });
+      }
+    } else {
+      pts2.push({ x: to.x, y: from.y });
+    }
+  }
+  pts2.push(to);
+  return pts2;
+}
+function waypointsToPath(pts2, cornerRadius) {
+  if (pts2.length < 2) return "";
+  if (pts2.length === 2 || cornerRadius <= 0) {
+    return "M " + pts2.map((p) => `${p.x} ${p.y}`).join(" L ");
+  }
+  const parts = [`M ${pts2[0].x} ${pts2[0].y}`];
+  for (let i = 1; i < pts2.length - 1; i++) {
+    const prev = pts2[i - 1];
+    const curr = pts2[i];
+    const next = pts2[i + 1];
+    const dxIn = curr.x - prev.x;
+    const dyIn = curr.y - prev.y;
+    const dxOut = next.x - curr.x;
+    const dyOut = next.y - curr.y;
+    const lenIn = Math.sqrt(dxIn * dxIn + dyIn * dyIn);
+    const lenOut = Math.sqrt(dxOut * dxOut + dyOut * dyOut);
+    const r = Math.min(cornerRadius, lenIn / 2, lenOut / 2);
+    if (r < 0.5) {
+      parts.push(`L ${curr.x} ${curr.y}`);
+      continue;
+    }
+    const arcStart = {
+      x: curr.x - dxIn / lenIn * r,
+      y: curr.y - dyIn / lenIn * r
+    };
+    const arcEnd = {
+      x: curr.x + dxOut / lenOut * r,
+      y: curr.y + dyOut / lenOut * r
+    };
+    const cross = dxIn * dyOut - dyIn * dxOut;
+    const sweep = cross > 0 ? 1 : 0;
+    parts.push(`L ${arcStart.x} ${arcStart.y}`);
+    parts.push(`A ${r} ${r} 0 0 ${sweep} ${arcEnd.x} ${arcEnd.y}`);
+  }
+  parts.push(`L ${pts2[pts2.length - 1].x} ${pts2[pts2.length - 1].y}`);
+  return parts.join(" ");
+}
+function buildCurvedPath(from, to, fromEdge, toEdge, curvature) {
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  const cpDist = Math.min(dist * Math.max(0.1, Math.min(1, curvature)), 200);
+  const fn = edgeNormal(fromEdge);
+  const tn = edgeNormal(toEdge);
+  const cp1 = { x: from.x + fn.dx * cpDist, y: from.y + fn.dy * cpDist };
+  const cp2 = { x: to.x + tn.dx * cpDist, y: to.y + tn.dy * cpDist };
+  return `M ${from.x} ${from.y} C ${cp1.x} ${cp1.y}, ${cp2.x} ${cp2.y}, ${to.x} ${to.y}`;
+}
+function resolveEdge(anchor, selfRect, otherRect) {
+  switch (anchor) {
+    case "top":
+    case "topLeft":
+    case "topRight":
+      return "top";
+    case "bottom":
+    case "bottomLeft":
+    case "bottomRight":
+      return "bottom";
+    case "left":
+      return "left";
+    case "right":
+      return "right";
+    case "center":
+    case "auto":
+    default:
+      return autoDetectEdge(selfRect, otherRect);
+  }
+}
+function autoDetectEdge(selfRect, otherRect) {
+  const selfCx = selfRect.x + selfRect.width / 2;
+  const selfCy = selfRect.y + selfRect.height / 2;
+  const otherCx = otherRect.x + otherRect.width / 2;
+  const otherCy = otherRect.y + otherRect.height / 2;
+  const dx = otherCx - selfCx;
+  const dy = otherCy - selfCy;
+  if (Math.abs(dx) > Math.abs(dy)) {
+    return dx > 0 ? "right" : "left";
+  } else {
+    return dy > 0 ? "bottom" : "top";
+  }
+}
+function edgePoint(rect, edge, t) {
+  switch (edge) {
+    case "top":
+      return { x: rect.x + rect.width * t, y: rect.y };
+    case "bottom":
+      return { x: rect.x + rect.width * t, y: rect.y + rect.height };
+    case "left":
+      return { x: rect.x, y: rect.y + rect.height * t };
+    case "right":
+      return { x: rect.x + rect.width, y: rect.y + rect.height * t };
+  }
+}
+function collectWorldRects(nodes, map) {
+  for (const node of nodes) {
+    map.set(node.id, node.worldRect);
+    if (node.children) {
+      collectWorldRects(node.children, map);
+    }
+  }
+}
+function findIrNode(ir, id) {
+  if (ir.id === id) return ir;
+  if (ir.children) {
+    for (const child of ir.children) {
+      const found = findIrNode(child, id);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function getSlotValue(graph, nodeId, slotKind) {
+  const slot = graph.slots.get(`${nodeId}.${slotKind}`);
+  return slot?.value;
+}
+
+// src/graph/font-loader.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+
+// src/index.ts
+function layout(ir, options) {
+  const { ir: normalizedIr, diagnostics: normDiag } = normalize(ir, options);
+  const graph = createGraph();
+  const { artifact, diagnostics: evalDiag } = evaluate(graph, normalizedIr);
+  return {
+    artifact,
+    diagnostics: [...normDiag, ...evalDiag]
+  };
+}
+function renderToSvg(ir, options) {
+  const { artifact } = layout(ir, options);
+  return renderSvg(artifact, { iconRegistry: options.iconRegistry });
+}
+function renderDrawTextToSvg(source, options) {
+  const { ir } = parseDrawText(source);
+  const opts = {
+    tokens: options?.tokens ?? defaultTokens(),
+    theme: options?.theme ?? defaultTheme()
+  };
+  return renderToSvg(ir, { ...opts, iconRegistry: options?.iconRegistry });
+}
+function renderDrawTsxToSvg(source, options) {
+  const { resolveImport, components, iconRegistry: iconRegistry2, ...rest } = options ?? {};
+  const compileOpts = resolveImport || components ? { resolveImport, components } : void 0;
+  const { ir } = compileDrawTsx(source, compileOpts);
+  const opts = {
+    tokens: rest.tokens ?? defaultTokens(),
+    theme: rest.theme ?? defaultTheme()
+  };
+  return renderToSvg(ir, { ...opts, iconRegistry: iconRegistry2 });
+}
+export {
+  ELEMENT_CATALOG,
+  FRAGMENT_MAP,
+  IrNodeSchema,
+  PROPERTY_CATALOG,
+  SimpleTextMeasurer,
+  TOKEN_CATALOG,
+  compileDrawTsx,
+  createAwsIconPack,
+  createGraph,
+  createIconRegistry,
+  defaultTheme,
+  defaultTokens,
+  evaluate,
+  kindToPascal,
+  layout,
+  normalize,
+  opClamp,
+  opConstant,
+  opMax,
+  opSum,
+  parseDrawText,
+  parseIr,
+  parseTheme,
+  parseTokens,
+  renderArrowMarkers,
+  renderConnector,
+  renderDrawTextToSvg,
+  renderDrawTsxToSvg,
+  renderShape,
+  renderSvg,
+  renderText,
+  renderToSvg,
+  resolveSlot,
+  resolveTokenRef
+};