@almadar/shell-web 0.0.0-stage → 1.0.0

package/dist/chunk-TXAUOLWZ.js

@@ -0,0 +1,490 @@
+import { traitLevelFromMounted } from './chunk-PCR37T3U.js';
+import { getStateRole } from './chunk-UXLE3IPR.js';
+import { useState, useLayoutEffect } from 'react';
+
+function useContainerWidth(ref) {
+  const [width, setWidth] = useState(null);
+  useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    setWidth(el.clientWidth);
+    if (typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(([entry]) => setWidth(entry.contentRect.width));
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [ref]);
+  return width;
+}
+
+// src/lib/avl-elk-layout.ts
+function stateWidth(transitionCount) {
+  if (transitionCount >= 5) return 160;
+  if (transitionCount >= 3) return 130;
+  return 110;
+}
+var STATE_H = 40;
+var elk;
+function loadElk() {
+  elk ??= import('elkjs/lib/elk.bundled.js').then(({ default: Elk }) => new Elk());
+  return elk;
+}
+function flowOrder(data) {
+  const byName = new Map(data.states.map((s) => [s.name, s]));
+  const seen = /* @__PURE__ */ new Set();
+  const queue = data.states.filter((s) => s.isInitial).map((s) => s.name);
+  const out = [];
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (seen.has(name)) continue;
+    const state = byName.get(name);
+    if (!state) continue;
+    seen.add(name);
+    out.push(state);
+    for (const t of data.transitions) if (t.from === name && !seen.has(t.to)) queue.push(t.to);
+  }
+  for (const s of data.states) if (!seen.has(s.name)) out.push(s);
+  return out;
+}
+async function computeTraitLayout(data, metrics) {
+  const transitionCounts = {};
+  for (const s of data.states) transitionCounts[s.name] = 0;
+  for (const t of data.transitions) {
+    transitionCounts[t.from] = (transitionCounts[t.from] ?? 0) + 1;
+    transitionCounts[t.to] = (transitionCounts[t.to] ?? 0) + 1;
+  }
+  const maxTC = Math.max(...Object.values(transitionCounts), 0);
+  const LABEL_BASE_W = 100;
+  const LABEL_H = 44;
+  const states = metrics ? flowOrder(data) : data.states;
+  const elkGraph = {
+    id: "root",
+    layoutOptions: {
+      "elk.algorithm": "layered",
+      "elk.direction": metrics?.direction === "rtl" ? "LEFT" : "RIGHT",
+      "elk.spacing.nodeNode": String(metrics?.nodeSpacing ?? 80),
+      "elk.spacing.edgeNode": "30",
+      "elk.spacing.edgeEdge": "24",
+      "elk.spacing.edgeLabel": "10",
+      "elk.spacing.labelLabel": "8",
+      "elk.layered.spacing.nodeNodeBetweenLayers": String(metrics?.layerSpacing ?? 100),
+      ...metrics?.orthogonal ? { "elk.edgeRouting": "ORTHOGONAL" } : {},
+      ...metrics ? { "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES", "elk.layered.cycleBreaking.strategy": "MODEL_ORDER" } : {},
+      "elk.edgeLabels.placement": "CENTER",
+      "elk.layered.mergeEdges": "false",
+      "elk.layered.nodePlacement.strategy": "NETWORK_SIMPLEX"
+    },
+    children: states.map((s) => {
+      const tc = transitionCounts[s.name] ?? 0;
+      const size = metrics ? metrics.nodeSize(s.name) : { width: stateWidth(tc), height: STATE_H };
+      return {
+        id: s.name,
+        width: size.width,
+        height: size.height,
+        labels: [{ text: s.name, width: size.width - 10, height: 14 }],
+        ...metrics && s.isInitial ? { layoutOptions: { "elk.layered.layering.layerConstraint": "FIRST" } } : {}
+      };
+    }),
+    edges: data.transitions.map((t, i) => {
+      const textW = Math.max(t.event.length * 8, 60);
+      const iconsW = Math.min(t.effects.length, 6) * 28 + 20;
+      const label = metrics ? metrics.labelSize(t) : { width: Math.max(textW, iconsW, LABEL_BASE_W), height: LABEL_H };
+      return {
+        id: `e${i}`,
+        sources: [t.from],
+        targets: [t.to],
+        labels: [{
+          text: t.event,
+          width: label.width,
+          height: label.height,
+          ...metrics ? { layoutOptions: { "elk.edgeLabels.inline": "true" } } : {}
+        }]
+      };
+    })
+  };
+  const layout = await (await loadElk()).layout(elkGraph);
+  const layoutChildren = layout.children ?? [];
+  const layoutEdges = layout.edges ?? [];
+  const nodeXMap = {};
+  for (const n of layoutChildren) {
+    nodeXMap[n.id] = n.x ?? 0;
+  }
+  const nodes = layoutChildren.map((n) => {
+    const name = n.id;
+    const stateInfo = data.states.find((s) => s.name === name);
+    const tc = transitionCounts[name] ?? 0;
+    return {
+      id: name,
+      x: n.x ?? 0,
+      y: n.y ?? 0,
+      width: n.width ?? 110,
+      height: n.height ?? STATE_H,
+      isInitial: stateInfo?.isInitial ?? void 0,
+      isTerminal: stateInfo?.isTerminal ?? void 0,
+      role: getStateRole(stateInfo?.isInitial ?? void 0, stateInfo?.isTerminal ?? void 0, tc, maxTC),
+      transitionCount: tc
+    };
+  });
+  const edges = layoutEdges.map((e, i) => {
+    const t = data.transitions[i];
+    const labels = e.labels ?? [];
+    const label = labels[0];
+    const sections = e.sections ?? [];
+    const points = [];
+    for (const section of sections) {
+      const bendPoints = section.bendPoints ?? [];
+      points.push({ x: section.startPoint.x, y: section.startPoint.y });
+      for (const bp of bendPoints) points.push({ x: bp.x, y: bp.y });
+      points.push({ x: section.endPoint.x, y: section.endPoint.y });
+    }
+    const isSelf = t.from === t.to;
+    const toX = nodeXMap[t.to] ?? 0;
+    const fromX = nodeXMap[t.from] ?? 0;
+    const isBackward = !isSelf && (metrics?.direction === "rtl" ? toX >= fromX : toX <= fromX);
+    const lw = label?.width ?? LABEL_BASE_W;
+    const lh = label?.height ?? LABEL_H;
+    return {
+      id: e.id,
+      from: t.from,
+      to: t.to,
+      event: t.event,
+      effects: t.effects,
+      guard: !!t.guard,
+      guardExpr: typeof t.guard === "string" ? t.guard : void 0,
+      index: t.index,
+      labelX: label?.x ?? 0,
+      labelY: label?.y ?? 0,
+      labelW: lw,
+      labelH: lh,
+      points,
+      isSelf,
+      isBackward
+    };
+  });
+  return {
+    nodes,
+    edges,
+    width: layout.width ?? 600,
+    height: layout.height ?? 400
+  };
+}
+function roundedEdgePath(points, radius) {
+  if (points.length < 3) return edgePath(points);
+  let d = `M ${points[0].x},${points[0].y}`;
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = points[i - 1];
+    const cur = points[i];
+    const next = points[i + 1];
+    const inLen = Math.hypot(cur.x - prev.x, cur.y - prev.y);
+    const outLen = Math.hypot(next.x - cur.x, next.y - cur.y);
+    const r = Math.min(radius, inLen / 2, outLen / 2);
+    if (r <= 0) {
+      d += ` L ${cur.x},${cur.y}`;
+      continue;
+    }
+    const ax = cur.x - (cur.x - prev.x) / inLen * r;
+    const ay = cur.y - (cur.y - prev.y) / inLen * r;
+    const bx = cur.x + (next.x - cur.x) / outLen * r;
+    const by = cur.y + (next.y - cur.y) / outLen * r;
+    d += ` L ${ax},${ay} Q ${cur.x},${cur.y} ${bx},${by}`;
+  }
+  const last = points[points.length - 1];
+  return `${d} L ${last.x},${last.y}`;
+}
+function edgePath(points) {
+  if (points.length === 0) return "";
+  let d = `M ${points[0].x},${points[0].y}`;
+  for (let i = 1; i < points.length; i++) d += ` L ${points[i].x},${points[i].y}`;
+  return d;
+}
+var BOX_PAD = 16;
+var BOX_HEAD_MACHINE = 46;
+var BOX_HEAD_CONTAINER = 38;
+var COLLAPSED_H = 56;
+var CHIP_H = 28;
+var HEAD_GLYPH = 40;
+var HEAD_TOGGLE = 28;
+var LOOP_FOLD = 3;
+var LOOP_LINE = 18;
+function loopKey(trait, state) {
+  return `${trait}\0${state}`;
+}
+var LANE_HEAD = 30;
+var LANE_MARGIN = 36;
+var LANE_MIN_WIDTH = 480;
+var PACK_ASPECT = 1.6;
+var PACK_GAP = 14;
+function sectionPoints(e) {
+  const points = [];
+  for (const section of e.sections ?? []) {
+    points.push({ x: section.startPoint.x, y: section.startPoint.y });
+    for (const bp of section.bendPoints ?? []) points.push({ x: bp.x, y: bp.y });
+    points.push({ x: section.endPoint.x, y: section.endPoint.y });
+  }
+  return points;
+}
+function boxWirePath(a, b) {
+  const ax = a.x + a.width / 2;
+  const ay = a.y + a.height / 2;
+  const bx = b.x + b.width / 2;
+  const by = b.y + b.height / 2;
+  if (b.x >= a.x + a.width) return [{ x: a.x + a.width, y: ay }, { x: b.x, y: by }];
+  if (a.x >= b.x + b.width) return [{ x: a.x, y: ay }, { x: b.x + b.width, y: by }];
+  if (by >= ay) return [{ x: ax, y: a.y + a.height }, { x: bx, y: b.y }];
+  return [{ x: ax, y: a.y }, { x: bx, y: b.y + b.height }];
+}
+function boxKind(trait, expandDepth, open, closed) {
+  if (trait.states.length <= 1) return "chip";
+  if (open.has(trait.trait)) return "machine";
+  if (closed.has(trait.trait)) return "collapsed";
+  return trait.depth < expandDepth ? "machine" : "collapsed";
+}
+function compactSize(trait, kind, charWidth) {
+  if (kind === "chip") return { width: Math.round(trait.trait.length * charWidth + 28 + HEAD_GLYPH), height: CHIP_H };
+  const sub = (trait.linkedEntity ?? "").length;
+  return { width: Math.max(132, Math.round(Math.max(trait.trait.length, sub) * charWidth + 64 + HEAD_GLYPH + HEAD_TOGGLE)), height: COLLAPSED_H };
+}
+function packOptions(padding, targetWidth) {
+  return {
+    "elk.algorithm": "rectpacking",
+    "elk.aspectRatio": String(PACK_ASPECT),
+    "elk.rectpacking.orderBySize": "false",
+    "elk.spacing.nodeNode": String(PACK_GAP),
+    "elk.padding": padding,
+    ...targetWidth === void 0 ? {} : { "elk.rectpacking.widthApproximation.targetWidth": String(targetWidth) }
+  };
+}
+async function computeOrbitalLayout(orbital, options) {
+  const { metrics, expandDepth, charWidth } = options;
+  const byName = new Map(orbital.traits.map((t) => [t.trait, t]));
+  const levels = new Map(orbital.traits.map((t) => [t.trait, traitLevelFromMounted(t)]));
+  const lane = orbital.traits.filter((t) => !t.renders && !t.linked);
+  const tree = orbital.traits.filter((t) => t.renders && !t.linked);
+  const linkedByOrbital = /* @__PURE__ */ new Map();
+  for (const t of orbital.traits.filter((x) => x.linked)) {
+    const key = t.orbital ?? "";
+    linkedByOrbital.set(key, [...linkedByOrbital.get(key) ?? [], t]);
+  }
+  const effectiveParent = /* @__PURE__ */ new Map();
+  for (const t of tree) {
+    let cur = t.parent === null ? void 0 : byName.get(t.parent);
+    while (cur !== void 0 && !cur.renders) cur = cur.parent === null ? void 0 : byName.get(cur.parent);
+    effectiveParent.set(t.trait, cur === void 0 ? null : cur.trait);
+  }
+  const childrenOf = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const t of tree) {
+    const p = effectiveParent.get(t.trait) ?? null;
+    if (p === null) roots.push(t);
+    else childrenOf.set(p, [...childrenOf.get(p) ?? [], t]);
+  }
+  const open = options.open ?? /* @__PURE__ */ new Set();
+  const closed = options.closed ?? /* @__PURE__ */ new Set();
+  const openLoops = options.openLoops ?? /* @__PURE__ */ new Set();
+  const loops = [];
+  const kinds = new Map(orbital.traits.map((t) => [t.trait, boxKind(t, expandDepth, open, closed)]));
+  const wirePairs = /* @__PURE__ */ new Map();
+  for (const w of orbital.wires) {
+    if (!byName.has(w.from) || !byName.has(w.to)) continue;
+    const key = `${w.from}\u2192${w.to}`;
+    const entry = wirePairs.get(key) ?? { from: w.from, to: w.to, pairs: [] };
+    entry.pairs.push({ event: w.event, triggers: w.triggers });
+    wirePairs.set(key, entry);
+  }
+  const wireLabel = (pairs) => [...new Set(pairs.map((p) => p.event))].join(", ");
+  const boxNode = (t) => {
+    const kind = kinds.get(t.trait) ?? "chip";
+    const kids = childrenOf.get(t.trait) ?? [];
+    const level = levels.get(t.trait);
+    const titleWidth = Math.round(Math.max(t.trait.length, (t.linkedEntity ?? "").length) * charWidth + 32 + HEAD_GLYPH + (kind === "chip" ? 0 : HEAD_TOGGLE));
+    if (kind !== "machine" && kids.length === 0) {
+      const size = compactSize(t, kind, charWidth);
+      return { id: `b:${t.trait}`, width: size.width, height: size.height };
+    }
+    const head = kind === "machine" ? BOX_HEAD_MACHINE : BOX_HEAD_CONTAINER;
+    const padding = `[top=${head},left=${BOX_PAD},bottom=${BOX_PAD},right=${BOX_PAD}]`;
+    const minimum = { "elk.nodeSize.constraints": "MINIMUM_SIZE", "elk.nodeSize.minimum": `(${titleWidth}, ${head + 20})` };
+    const kidNodes = kids.map(boxNode);
+    if (kind !== "machine" || level === void 0) {
+      return { id: `b:${t.trait}`, children: kidNodes, layoutOptions: { ...packOptions(padding), ...minimum } };
+    }
+    const selfCount = /* @__PURE__ */ new Map();
+    for (const tr of level.transitions) if (tr.from === tr.to) selfCount.set(tr.from, (selfCount.get(tr.from) ?? 0) + 1);
+    const folds = (tr) => tr.from === tr.to && (selfCount.get(tr.from) ?? 0) >= LOOP_FOLD;
+    for (const [state, count] of selfCount) {
+      if (count < LOOP_FOLD) continue;
+      loops.push({
+        trait: t.trait,
+        state,
+        events: level.transitions.filter((tr) => tr.from === state && tr.to === state).map((tr) => ({ event: tr.event, index: tr.index })),
+        open: openLoops.has(loopKey(t.trait, state))
+      });
+    }
+    const stateNodes = flowOrder(level).map((s) => {
+      const size = metrics.nodeSize(s.name);
+      const count = (selfCount.get(s.name) ?? 0) >= LOOP_FOLD ? selfCount.get(s.name) ?? 0 : 0;
+      const extra = count === 0 ? 0 : openLoops.has(loopKey(t.trait, s.name)) ? LOOP_LINE * (count + 1) + 8 : LOOP_LINE;
+      const longest = count === 0 ? 0 : Math.max(...level.transitions.filter((tr) => tr.from === s.name && tr.to === s.name).map((tr) => tr.event.length));
+      return {
+        id: `s:${t.trait}:${s.name}`,
+        width: Math.max(size.width, extra > LOOP_LINE ? Math.round(longest * charWidth + 40) : size.width),
+        height: size.height + extra,
+        layoutOptions: { "elk.partitioning.partition": "0", ...s.isInitial ? { "elk.layered.layering.layerConstraint": "FIRST" } : {} }
+      };
+    });
+    const group = kidNodes.length === 0 ? [] : [{
+      id: `k:${t.trait}`,
+      children: kidNodes,
+      layoutOptions: { ...packOptions("[top=0,left=0,bottom=0,right=0]"), "elk.partitioning.partition": "1" }
+    }];
+    return {
+      id: `b:${t.trait}`,
+      children: [...stateNodes, ...group],
+      edges: level.transitions.flatMap((tr, i) => {
+        if (folds(tr)) return [];
+        const size = metrics.labelSize(tr);
+        return [{
+          id: `x:${t.trait}:${i}`,
+          sources: [`s:${t.trait}:${tr.from}`],
+          targets: [`s:${t.trait}:${tr.to}`],
+          labels: [{ text: tr.event, width: size.width, height: size.height, layoutOptions: { "elk.edgeLabels.inline": "true" } }]
+        }];
+      }),
+      layoutOptions: {
+        "elk.algorithm": "layered",
+        "elk.direction": metrics.direction === "rtl" ? "LEFT" : "RIGHT",
+        "elk.padding": padding,
+        "elk.partitioning.activate": "true",
+        "elk.spacing.nodeNode": String(metrics.nodeSpacing),
+        "elk.spacing.edgeNode": "30",
+        "elk.spacing.edgeEdge": "24",
+        "elk.spacing.edgeLabel": "10",
+        "elk.layered.spacing.nodeNodeBetweenLayers": String(metrics.layerSpacing),
+        "elk.edgeRouting": "ORTHOGONAL",
+        "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
+        "elk.layered.cycleBreaking.strategy": "MODEL_ORDER",
+        "elk.edgeLabels.placement": "CENTER",
+        "elk.layered.mergeEdges": "false",
+        "elk.layered.nodePlacement.strategy": "NETWORK_SIMPLEX",
+        ...minimum
+      }
+    };
+  };
+  const graph = {
+    id: "root",
+    layoutOptions: { ...packOptions("[top=0,left=0,bottom=0,right=0]"), "elk.hierarchyHandling": "SEPARATE_CHILDREN" },
+    children: roots.map(boxNode)
+  };
+  const elkEngine = await loadElk();
+  const result = roots.length === 0 ? { width: 0, height: 0 } : await elkEngine.layout(graph);
+  const boxes = [];
+  const groups = [];
+  const states = [];
+  const transitionEdges = [];
+  const walk = (node, ox, oy, parent) => {
+    for (const e of node.edges ?? []) {
+      const [, ...rest] = e.id.split(":");
+      const index = Number(rest[rest.length - 1]);
+      const trait = rest.slice(0, -1).join(":");
+      const tr = levels.get(trait)?.transitions[index];
+      if (tr === void 0) continue;
+      const label = (e.labels ?? [])[0];
+      transitionEdges.push({
+        id: e.id,
+        trait,
+        index: tr.index,
+        from: tr.from,
+        to: tr.to,
+        event: tr.event,
+        points: sectionPoints(e).map((p) => ({ x: p.x + ox, y: p.y + oy })),
+        labelX: (label?.x ?? 0) + ox,
+        labelY: (label?.y ?? 0) + oy,
+        labelW: label?.width ?? 0,
+        labelH: label?.height ?? 0,
+        isSelf: tr.from === tr.to
+      });
+    }
+    for (const c of node.children ?? []) {
+      const x = ox + (c.x ?? 0);
+      const y = oy + (c.y ?? 0);
+      if (c.id.startsWith("b:")) {
+        const name = c.id.slice(2);
+        boxes.push({ trait: name, kind: kinds.get(name) ?? "chip", lane: false, parent, container: (childrenOf.get(name) ?? []).length > 0, x, y, width: c.width ?? 0, height: c.height ?? 0 });
+        walk(c, x, y, name);
+      } else if (c.id.startsWith("g:")) {
+        groups.push({ orbital: c.id.slice(2), x, y, width: c.width ?? 0, height: c.height ?? 0 });
+        walk(c, x, y, null);
+      } else if (c.id.startsWith("k:")) {
+        walk(c, x, y, parent);
+      } else if (c.id.startsWith("s:")) {
+        const [, trait, ...rest] = c.id.split(":");
+        const name = rest.join(":");
+        const info = byName.get(trait)?.states.find((s) => s.name === name);
+        states.push({ trait, name, isInitial: info?.isInitial ?? false, isTerminal: info?.isTerminal ?? false, x, y, width: c.width ?? 0, height: c.height ?? 0 });
+      }
+    }
+  };
+  walk(result, 0, 0, null);
+  let width = result.width ?? 0;
+  let height = result.height ?? 0;
+  let laneTop = null;
+  if (lane.length > 0) {
+    laneTop = height + LANE_MARGIN;
+    const laneWidth = Math.max(width, LANE_MIN_WIDTH);
+    const chipSize = new Map(lane.map((t) => [t.trait, compactSize(t, kinds.get(t.trait) === "chip" ? "chip" : "collapsed", charWidth)]));
+    const packed = await elkEngine.layout({
+      id: "lane",
+      layoutOptions: packOptions("[top=0,left=0,bottom=0,right=0]", laneWidth),
+      children: lane.map((t) => ({ id: `b:${t.trait}`, width: chipSize.get(t.trait)?.width ?? 0, height: chipSize.get(t.trait)?.height ?? 0 }))
+    });
+    for (const c of packed.children ?? []) {
+      const name = c.id.slice(2);
+      boxes.push({ trait: name, kind: kinds.get(name) === "chip" ? "chip" : "collapsed", lane: true, parent: null, container: false, x: c.x ?? 0, y: laneTop + LANE_HEAD + (c.y ?? 0), width: c.width ?? 0, height: c.height ?? 0 });
+    }
+    width = Math.max(width, packed.width ?? 0);
+    height = laneTop + LANE_HEAD + (packed.height ?? 0);
+  }
+  let groupTop = null;
+  if (linkedByOrbital.size > 0) {
+    groupTop = height + LANE_MARGIN;
+    const padding = `[top=${BOX_HEAD_CONTAINER},left=${BOX_PAD},bottom=${BOX_PAD},right=${BOX_PAD}]`;
+    const packed = await elkEngine.layout({
+      id: "groups",
+      layoutOptions: { ...packOptions("[top=0,left=0,bottom=0,right=0]", Math.max(width, LANE_MIN_WIDTH)), "elk.hierarchyHandling": "SEPARATE_CHILDREN" },
+      children: [...linkedByOrbital].map(([name, traits]) => ({
+        id: `g:${name}`,
+        children: traits.map(boxNode),
+        layoutOptions: {
+          ...packOptions(padding),
+          "elk.nodeSize.constraints": "MINIMUM_SIZE",
+          "elk.nodeSize.minimum": `(${Math.round(name.length * charWidth + 32 + HEAD_GLYPH)}, ${BOX_HEAD_CONTAINER + 20})`
+        }
+      }))
+    });
+    walk(packed, 0, groupTop + LANE_HEAD, null);
+    width = Math.max(width, packed.width ?? 0);
+    height = groupTop + LANE_HEAD + (packed.height ?? 0);
+  }
+  const embeds = [];
+  for (const t of tree) {
+    const parent = effectiveParent.get(t.trait) ?? null;
+    const child = boxes.find((b) => b.trait === t.trait);
+    if (parent === null || child === void 0) continue;
+    for (const state of t.embeddedIn) {
+      const node = states.find((s) => s.trait === parent && s.name === state);
+      if (node !== void 0) embeds.push({ trait: t.trait, state, points: boxWirePath(node, child) });
+    }
+  }
+  const wires = [];
+  for (const [key, w] of wirePairs) {
+    const a = boxes.find((b2) => b2.trait === w.from);
+    const b = boxes.find((x) => x.trait === w.to);
+    if (a === void 0 || b === void 0) continue;
+    const points = boxWirePath(a, b);
+    const size = options.wireLabelSize(wireLabel(w.pairs));
+    const mid = { x: (points[0].x + points[1].x) / 2, y: (points[0].y + points[1].y) / 2 };
+    wires.push({ key, from: w.from, to: w.to, pairs: w.pairs, points, labelX: mid.x - size.width / 2, labelY: mid.y - size.height / 2, labelW: size.width, labelH: size.height });
+  }
+  return { boxes, loops, groups, groupTop, states, edges: transitionEdges, embeds, wires, laneTop, width, height };
+}
+
+export { LOOP_LINE, computeOrbitalLayout, computeTraitLayout, edgePath, loopKey, roundedEdgePath, useContainerWidth };

package/dist/chunk-TZZBINQY.js

@@ -0,0 +1,82 @@
+// src/lib/jazari/svg-paths.ts
+function gearTeethPath(cx, cy, innerRadius, outerRadius, numTeeth) {
+  const parts = [];
+  const angleStep = Math.PI * 2 / numTeeth;
+  const halfTooth = angleStep * 0.25;
+  for (let i = 0; i < numTeeth; i++) {
+    const baseAngle = i * angleStep;
+    const x0 = cx + innerRadius * Math.cos(baseAngle - halfTooth);
+    const y0 = cy + innerRadius * Math.sin(baseAngle - halfTooth);
+    const x1 = cx + outerRadius * Math.cos(baseAngle - halfTooth * 0.4);
+    const y1 = cy + outerRadius * Math.sin(baseAngle - halfTooth * 0.4);
+    const x2 = cx + outerRadius * Math.cos(baseAngle + halfTooth * 0.4);
+    const y2 = cy + outerRadius * Math.sin(baseAngle + halfTooth * 0.4);
+    const x3 = cx + innerRadius * Math.cos(baseAngle + halfTooth);
+    const y3 = cy + innerRadius * Math.sin(baseAngle + halfTooth);
+    if (i === 0) {
+      parts.push(`M ${x0.toFixed(1)} ${y0.toFixed(1)}`);
+    } else {
+      parts.push(`L ${x0.toFixed(1)} ${y0.toFixed(1)}`);
+    }
+    parts.push(`L ${x1.toFixed(1)} ${y1.toFixed(1)}`);
+    parts.push(`L ${x2.toFixed(1)} ${y2.toFixed(1)}`);
+    parts.push(`L ${x3.toFixed(1)} ${y3.toFixed(1)}`);
+  }
+  parts.push("Z");
+  return parts.join(" ");
+}
+function lockIconPath(cx, cy, size) {
+  const bodyW = size * 0.7;
+  const bodyH = size * 0.5;
+  const bodyX = cx - bodyW / 2;
+  const bodyY = cy - bodyH / 4;
+  const body = `M ${bodyX.toFixed(1)} ${bodyY.toFixed(1)} h ${bodyW.toFixed(1)} v ${bodyH.toFixed(1)} h ${(-bodyW).toFixed(1)} Z`;
+  const shR = size * 0.28;
+  const shY = bodyY;
+  const shackle = `M ${(cx - shR).toFixed(1)} ${shY.toFixed(1)} A ${shR.toFixed(1)} ${(shR * 1.2).toFixed(1)} 0 1 1 ${(cx + shR).toFixed(1)} ${shY.toFixed(1)}`;
+  const kR = size * 0.08;
+  const kY = bodyY + bodyH * 0.35;
+  const keyhole = `M ${cx.toFixed(1)} ${(kY - kR).toFixed(1)} a ${kR.toFixed(1)} ${kR.toFixed(1)} 0 1 1 0 ${(kR * 2).toFixed(1)} a ${kR.toFixed(1)} ${kR.toFixed(1)} 0 1 1 0 ${(-kR * 2).toFixed(1)} Z`;
+  return `${body} ${shackle} ${keyhole}`;
+}
+function brainIconPath(cx, cy, size) {
+  const s = size / 2;
+  return [
+    `M ${cx.toFixed(1)} ${(cy - s).toFixed(1)}`,
+    `C ${(cx - s * 1.2).toFixed(1)} ${(cy - s).toFixed(1)}, ${(cx - s * 1.3).toFixed(1)} ${(cy + s * 0.3).toFixed(1)}, ${cx.toFixed(1)} ${(cy + s).toFixed(1)}`,
+    `C ${(cx + s * 1.3).toFixed(1)} ${(cy + s * 0.3).toFixed(1)}, ${(cx + s * 1.2).toFixed(1)} ${(cy - s).toFixed(1)}, ${cx.toFixed(1)} ${(cy - s).toFixed(1)}`,
+    "Z",
+    // Dividing line
+    `M ${cx.toFixed(1)} ${(cy - s * 0.8).toFixed(1)}`,
+    `C ${(cx - s * 0.2).toFixed(1)} ${(cy - s * 0.2).toFixed(1)}, ${(cx + s * 0.2).toFixed(1)} ${(cy + s * 0.2).toFixed(1)}, ${cx.toFixed(1)} ${(cy + s * 0.8).toFixed(1)}`
+  ].join(" ");
+}
+function pipeIconPath(cx, cy, size) {
+  const w = size * 0.6;
+  const h = size * 0.3;
+  const flangeW = size * 0.8;
+  const flangeH = size * 0.1;
+  const tube = `M ${(cx - w / 2).toFixed(1)} ${(cy - h / 2).toFixed(1)} h ${w.toFixed(1)} v ${h.toFixed(1)} h ${(-w).toFixed(1)} Z`;
+  const lf = `M ${(cx - flangeW / 2).toFixed(1)} ${(cy - h / 2 - flangeH).toFixed(1)} h ${flangeH.toFixed(1)} v ${(h + flangeH * 2).toFixed(1)} h ${(-flangeH).toFixed(1)} Z`;
+  const rf = `M ${(cx + flangeW / 2 - flangeH).toFixed(1)} ${(cy - h / 2 - flangeH).toFixed(1)} h ${flangeH.toFixed(1)} v ${(h + flangeH * 2).toFixed(1)} h ${(-flangeH).toFixed(1)} Z`;
+  return `${tube} ${lf} ${rf}`;
+}
+function eightPointedStarPath(cx, cy, outerR, innerR) {
+  const points = [];
+  const numPoints = 8;
+  const angleStep = Math.PI / numPoints;
+  for (let i = 0; i < numPoints * 2; i++) {
+    const angle = i * angleStep - Math.PI / 2;
+    const r = i % 2 === 0 ? outerR : innerR;
+    const x = cx + r * Math.cos(angle);
+    const y = cy + r * Math.sin(angle);
+    points.push(`${i === 0 ? "M" : "L"} ${x.toFixed(1)} ${y.toFixed(1)}`);
+  }
+  points.push("Z");
+  return points.join(" ");
+}
+function arrowheadPath(size) {
+  return `M 0 0 L ${size} ${size / 2} L 0 ${size} Z`;
+}
+
+export { arrowheadPath, brainIconPath, eightPointedStarPath, gearTeethPath, lockIconPath, pipeIconPath };

package/dist/chunk-UTDC2NEA.js

@@ -0,0 +1,14 @@
+import { ThemeProvider, useTheme } from './chunk-4YXBKHHM.js';
+
+// src/providers/DesignThemeContext.tsx
+var DesignThemeProvider = ThemeProvider;
+function useDesignTheme() {
+  const { theme, setTheme, availableThemes } = useTheme();
+  return {
+    designTheme: theme,
+    setDesignTheme: setTheme,
+    availableThemes: availableThemes.map((t) => t.name)
+  };
+}
+
+export { DesignThemeProvider, useDesignTheme };