@floegence/floe-webapp-core 0.86.11 → 0.86.13

package/dist/components/graph/layout.js

@@ -1,48 +1,49 @@
-import { applyGraphPositions as b } from "./positions.js";
+import { applyGraphPositions as G } from "./positions.js";
 import { computePackedGraphLayout as k } from "./packing.js";
-function $(a) {
-  const o = /* @__PURE__ */ new Set(), c = (t) => {
-    if (!t || o.has(t)) throw new Error(`Duplicate or empty graph ID: ${t}`);
-    o.add(t);
-  }, i = new Map(a.nodes.map((t) => [t.id, t]));
-  for (const t of a.nodes) {
+function $(d) {
+  const r = /* @__PURE__ */ new Set(), c = (t) => {
+    if (!t || r.has(t)) throw new Error(`Duplicate or empty graph ID: ${t}`);
+    r.add(t);
+  }, i = new Map(d.nodes.map((t) => [t.id, t]));
+  for (const t of d.nodes) {
     if (c(t.id), ![t.width, t.height].every((n) => Number.isFinite(n) && n > 0))
       throw new Error(`Invalid dimensions for graph node: ${t.id}`);
     for (const n of t.ports ?? []) c(n.id);
     const s = /* @__PURE__ */ new Set([t.id]);
-    let r = t.parentId;
-    for (; r !== void 0; ) {
-      const n = i.get(r);
+    let o = t.parentId;
+    for (; o !== void 0; ) {
+      const n = i.get(o);
       if (!n || n.kind !== "group")
         throw new Error(`Invalid parent for graph node: ${t.id}`);
-      if (s.has(r)) throw new Error(`Cyclic graph containment: ${t.id}`);
-      s.add(r), r = n.parentId;
+      if (s.has(o)) throw new Error(`Cyclic graph containment: ${t.id}`);
+      s.add(o), o = n.parentId;
     }
   }
-  for (const t of a.edges) {
+  for (const t of d.edges) {
     c(t.id);
-    for (const [s, r] of [
+    for (const [s, o] of [
       [t.source, t.sourcePort],
       [t.target, t.targetPort]
     ]) {
       const n = i.get(s);
-      if (!n || r !== void 0 && !n.ports?.some((h) => h.id === r))
+      if (!n || o !== void 0 && !n.ports?.some((h) => h.id === o))
         throw new Error(`Invalid endpoint for graph edge: ${t.id}`);
     }
   }
 }
-async function P(a, o, c) {
-  $(a);
-  const i = O(a, o);
-  if (o.aspectRatio !== void 0 && (!Number.isFinite(o.aspectRatio) || o.aspectRatio <= 0))
+async function P(d, r, c) {
+  if ($(d), r.edgeClearance !== void 0 && (!Number.isFinite(r.edgeClearance) || r.edgeClearance < 0))
+    throw new Error("Graph edge clearance must be finite and nonnegative");
+  const i = N(d, r);
+  if (r.aspectRatio !== void 0 && (!Number.isFinite(r.aspectRatio) || r.aspectRatio <= 0))
     throw new Error("Graph layout aspect ratio must be finite and positive");
-  const t = o.groupPadding ?? { top: 64, right: 28, bottom: 28, left: 28 };
-  if (![...Object.values(t), o.spacing ?? 64].every((e) => Number.isFinite(e) && e >= 0))
+  const t = r.groupPadding ?? { top: 64, right: 28, bottom: 28, left: 28 };
+  if (![...Object.values(t), r.spacing ?? 64].every((e) => Number.isFinite(e) && e >= 0))
     throw new Error("Graph layout spacing must be finite and nonnegative");
-  if (o.layers && (M(a, o.layers), o.positionMode === "fixed" && o.positions?.length))
+  if (r.layers && (O(d, r.layers), r.positionMode === "fixed" && r.positions?.length))
     throw new Error("Fixed positions cannot be combined with graph layers");
-  if (o.aspectRatio !== void 0 || o.layers)
-    return k(i, o, c);
+  if (r.aspectRatio !== void 0 || r.layers)
+    return k(i, r, c);
   const s = /* @__PURE__ */ new Map();
   for (const e of i.nodes)
     s.set(e.id, {
@@ -50,29 +51,29 @@ async function P(a, o, c) {
       width: e.width,
       height: e.height,
       ...e.kind === "group" ? { children: [] } : {},
-      ports: e.ports?.map((d) => ({
-        id: d.id,
+      ports: e.ports?.map((a) => ({
+        id: a.id,
         width: 1,
         height: 1,
-        layoutOptions: { "elk.port.side": d.side }
+        layoutOptions: { "elk.port.side": a.side }
       })),
       layoutOptions: {
         "elk.portConstraints": "FIXED_ORDER",
         "elk.padding": `[top=${t.top},left=${t.left},bottom=${t.bottom},right=${t.right}]`
       }
     });
-  const r = [];
+  const o = [];
   for (const e of i.nodes)
-    (e.parentId ? s.get(e.parentId).children : r).push(s.get(e.id));
+    (e.parentId ? s.get(e.parentId).children : o).push(s.get(e.id));
   const n = /* @__PURE__ */ new Set([
-    ...i.nodes.flatMap((e) => [e.id, ...(e.ports ?? []).map((d) => d.id)]),
+    ...i.nodes.flatMap((e) => [e.id, ...(e.ports ?? []).map((a) => a.id)]),
     ...i.edges.map((e) => e.id)
   ]);
   let h = "$graph";
   for (; n.has(h); ) h += "$";
   const p = await c.layout({
     id: h,
-    children: r,
+    children: o,
     edges: i.edges.map((e) => ({
       id: e.id,
       sources: [e.sourcePort ?? e.source],
@@ -80,20 +81,20 @@ async function P(a, o, c) {
     })),
     layoutOptions: {
       "elk.algorithm": "layered",
-      "elk.direction": o.direction ?? "RIGHT",
+      "elk.direction": r.direction ?? "RIGHT",
       "elk.edgeRouting": "ORTHOGONAL",
       "elk.hierarchyHandling": "INCLUDE_CHILDREN",
-      "elk.spacing.nodeNode": String(o.spacing ?? 64),
-      "elk.layered.spacing.nodeNodeBetweenLayers": String(o.spacing ?? 64),
+      "elk.spacing.nodeNode": String(r.spacing ?? 64),
+      "elk.layered.spacing.nodeNodeBetweenLayers": String(r.spacing ?? 64),
       "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
       "elk.randomSeed": "1"
     }
-  }), y = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Map(), E = (e) => {
-    for (const d of e.edges ?? []) {
-      const g = d.container ?? e.id, f = y.get(g) ?? { x: 0, y: 0 };
-      x.set(
-        d.id,
-        (d.sections ?? []).map(
+  }), y = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Map(), x = (e) => {
+    for (const a of e.edges ?? []) {
+      const g = a.container ?? e.id, f = y.get(g) ?? { x: 0, y: 0 };
+      E.set(
+        a.id,
+        (a.sections ?? []).map(
           (l) => [l.startPoint, ...l.bendPoints ?? [], l.endPoint].map((m) => ({
             x: m.x + f.x,
             y: m.y + f.y
@@ -101,55 +102,55 @@ async function P(a, o, c) {
         )
       );
     }
-    for (const d of e.children ?? []) E(d);
-  }, v = (e, d, g) => {
-    const f = d + (e.x ?? 0), l = g + (e.y ?? 0);
+    for (const a of e.children ?? []) x(a);
+  }, v = (e, a, g) => {
+    const f = a + (e.x ?? 0), l = g + (e.y ?? 0);
     y.set(e.id, { x: f, y: l, width: e.width ?? 0, height: e.height ?? 0 });
     for (const m of e.children ?? []) v(m, f, l);
   };
   for (const e of p.children ?? []) v(e, 0, 0);
-  E(p);
-  const w = (!o.positions?.length || o.positionMode === "compact") && o.anchor && y.get(o.anchor.nodeId), u = w ? o.anchor.position.x - w.x : 0, I = w ? o.anchor.position.y - w.y : 0, G = i.nodes.map((e) => {
-    const d = y.get(e.id);
-    return { ...e, ...d, x: d.x + u, y: d.y + I };
+  x(p);
+  const w = (!r.positions?.length || r.positionMode === "compact") && r.anchor && y.get(r.anchor.nodeId), u = w ? r.anchor.position.x - w.x : 0, I = w ? r.anchor.position.y - w.y : 0, b = i.nodes.map((e) => {
+    const a = y.get(e.id);
+    return { ...e, ...a, x: a.x + u, y: a.y + I };
   });
-  return b(
+  return G(
     {
-      nodes: G,
+      nodes: b,
       edges: i.edges.map((e) => ({
         ...e,
-        sections: (x.get(e.id) ?? []).map(
-          (d) => d.map((g) => ({ x: g.x + u, y: g.y + I }))
+        sections: (E.get(e.id) ?? []).map(
+          (a) => a.map((g) => ({ x: g.x + u, y: g.y + I }))
         )
       })),
       bounds: { x: u, y: I, width: p.width ?? 0, height: p.height ?? 0 }
     },
-    o,
+    r,
     i.nodes
   );
 }
-function O(a, o) {
-  if (o.positionMode !== "compact" || !o.positions?.length) return a;
-  const c = o.direction ?? "RIGHT", i = new Map(
-    o.positions.map((r) => [
-      r.nodeId,
-      c === "RIGHT" || c === "LEFT" ? r.y : r.x
+function N(d, r) {
+  if (r.positionMode !== "compact" || !r.positions?.length) return d;
+  const c = r.direction ?? "RIGHT", i = new Map(
+    r.positions.map((o) => [
+      o.nodeId,
+      c === "RIGHT" || c === "LEFT" ? o.y : o.x
     ])
-  ), t = new Map(a.nodes.map((r, n) => [r.id, n]));
-  return { nodes: [...a.nodes].sort((r, n) => {
-    const h = (r.parentId ?? "").localeCompare(n.parentId ?? ""), p = o.layers && !r.parentId && !n.parentId ? 0 : (i.get(r.id) ?? 1 / 0) - (i.get(n.id) ?? 1 / 0);
-    return h || p || t.get(r.id) - t.get(n.id);
-  }), edges: a.edges };
+  ), t = new Map(d.nodes.map((o, n) => [o.id, n]));
+  return { nodes: [...d.nodes].sort((o, n) => {
+    const h = (o.parentId ?? "").localeCompare(n.parentId ?? ""), p = r.layers && !o.parentId && !n.parentId ? 0 : (i.get(o.id) ?? 1 / 0) - (i.get(n.id) ?? 1 / 0);
+    return h || p || t.get(o.id) - t.get(n.id);
+  }), edges: d.edges };
 }
-function M(a, o) {
-  const c = new Map(a.nodes.map((t) => [t.id, t])), i = /* @__PURE__ */ new Set();
-  for (const [t, s] of o.entries()) {
+function O(d, r) {
+  const c = new Map(d.nodes.map((t) => [t.id, t])), i = /* @__PURE__ */ new Set();
+  for (const [t, s] of r.entries()) {
     if (!s.length) throw new Error(`Graph layer must not be empty: ${t}`);
-    for (const r of s) {
-      const n = c.get(r);
-      if (!n || n.parentId) throw new Error(`Graph layer object must be a root node: ${r}`);
-      if (i.has(r)) throw new Error(`Graph object appears in multiple layers: ${r}`);
-      i.add(r);
+    for (const o of s) {
+      const n = c.get(o);
+      if (!n || n.parentId) throw new Error(`Graph layer object must be a root node: ${o}`);
+      if (i.has(o)) throw new Error(`Graph object appears in multiple layers: ${o}`);
+      i.add(o);
     }
   }
 }

package/dist/components/graph/packing.js

@@ -1,6 +1,6 @@
 import { applyGraphPositions as $ } from "./positions.js";
 import { routeGraphGeometry as P } from "./routing.js";
-async function j(f, i, S) {
+async function j(f, s, S) {
   const y = new Map(f.nodes.map((e) => [e.id, { ...e, x: 0, y: 0 }])), O = new Map(f.nodes.map((e, d) => [e.id, d])), m = /* @__PURE__ */ new Map();
   for (const e of y.values()) {
     const d = m.get(e.parentId) ?? [];
@@ -12,22 +12,22 @@ async function j(f, i, S) {
   ]);
   let T = "$packed";
   for (; p.has(T); ) T += "$";
-  const k = i.groupPadding ?? { top: 64, right: 28, bottom: 28, left: 28 }, E = i.direction ?? "RIGHT", w = new Map(
-    (i.positions ?? []).map((e) => [
+  const k = s.groupPadding ?? { top: 64, right: 28, bottom: 28, left: 28 }, E = s.direction ?? "RIGHT", w = new Map(
+    (s.positions ?? []).map((e) => [
       e.nodeId,
       E === "RIGHT" || E === "LEFT" ? e.y : e.x
     ])
-  ), I = (e, d, s) => {
-    e.x += d, e.y += s;
-    for (const v of m.get(e.id) ?? []) I(v, d, s);
+  ), I = (e, d, i) => {
+    e.x += d, e.y += i;
+    for (const v of m.get(e.id) ?? []) I(v, d, i);
   }, x = (e, d) => {
-    let s = y.get(e);
-    for (; s && s.parentId !== d; )
-      s = s.parentId ? y.get(s.parentId) : void 0;
-    return s;
+    let i = y.get(e);
+    for (; i && i.parentId !== d; )
+      i = i.parentId ? y.get(i.parentId) : void 0;
+    return i;
   }, G = async (e) => {
     const d = [...m.get(e) ?? []];
-    (e !== void 0 || !i.layers) && d.sort(
+    (e !== void 0 || !s.layers) && d.sort(
       (o, a) => (w.get(o.id) ?? 1 / 0) - (w.get(a.id) ?? 1 / 0) || O.get(o.id) - O.get(a.id)
     );
     for (const o of d) {
@@ -36,28 +36,28 @@ async function j(f, i, S) {
       o.width = Math.max(o.width, a.width), o.height = Math.max(o.height, a.height);
     }
     if (!d.length) return { width: 0, height: 0 };
-    if (e === void 0 && i.layers)
-      return z(d, f, i, x, I);
-    const s = /* @__PURE__ */ new Map();
+    if (e === void 0 && s.layers)
+      return z(d, f, s, x, I);
+    const i = /* @__PURE__ */ new Map();
     for (const o of f.edges) {
       const a = x(o.source, e), M = x(o.target, e);
       if (!a || !M || a.id === M.id) continue;
       const H = JSON.stringify([a.id, M.id]);
-      s.has(H) || s.set(H, { id: o.id, sources: [a.id], targets: [M.id] });
+      i.has(H) || i.set(H, { id: o.id, sources: [a.id], targets: [M.id] });
     }
     const v = await S.layout({
       id: e ?? T,
       children: d.map((o) => ({ id: o.id, width: o.width, height: o.height })),
-      edges: [...s.values()],
+      edges: [...i.values()],
       layoutOptions: {
-        "elk.algorithm": s.size ? "layered" : "rectpacking",
+        "elk.algorithm": i.size ? "layered" : "rectpacking",
         "elk.direction": E,
         "elk.edgeRouting": "ORTHOGONAL",
         "elk.separateConnectedComponents": "true",
-        ...i.aspectRatio !== void 0 ? { "elk.aspectRatio": String(i.aspectRatio) } : {},
-        "elk.spacing.componentComponent": String(i.spacing ?? 64),
-        "elk.spacing.nodeNode": String(i.spacing ?? 64),
-        "elk.layered.spacing.nodeNodeBetweenLayers": String(i.spacing ?? 64),
+        ...s.aspectRatio !== void 0 ? { "elk.aspectRatio": String(s.aspectRatio) } : {},
+        "elk.spacing.componentComponent": String(s.spacing ?? 64),
+        "elk.spacing.nodeNode": String(s.spacing ?? 64),
+        "elk.layered.spacing.nodeNodeBetweenLayers": String(s.spacing ?? 64),
         "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
         "elk.padding": e ? `[top=${k.top},left=${k.left},bottom=${k.bottom},right=${k.right}]` : "[top=12,left=12,bottom=12,right=12]",
         "elk.randomSeed": "1"
@@ -68,23 +68,23 @@ async function j(f, i, S) {
       I(a, (o.x ?? 0) - a.x, (o.y ?? 0) - a.y);
     }
     return { width: v.width ?? 0, height: v.height ?? 0 };
-  }, u = await G(), R = (!i.positions?.length || i.positionMode === "compact" || i.layers) && i.anchor && y.get(i.anchor.nodeId);
+  }, u = await G(), R = (!s.positions?.length || s.positionMode === "compact" || s.layers) && s.anchor && y.get(s.anchor.nodeId);
   if (R) {
-    const e = i.anchor.position.x - R.x, d = i.anchor.position.y - R.y;
-    for (const s of m.get(void 0) ?? []) I(s, e, d);
+    const e = s.anchor.position.x - R.x, d = s.anchor.position.y - R.y;
+    for (const i of m.get(void 0) ?? []) I(i, e, d);
   }
   const C = {
     nodes: [...y.values()],
     edges: f.edges.map((e) => ({ ...e, sections: [] })),
     bounds: { x: 0, y: 0, ...u }
   };
-  return i.positions?.length && i.positionMode !== "compact" && !i.layers ? $(C, i, f.nodes) : P(C);
+  return s.positions?.length && s.positionMode !== "compact" && !s.layers ? $(C, s, f.nodes) : P(C, s);
 }
-function z(f, i, S, y, O) {
+function z(f, s, S, y, O) {
   const m = S.direction ?? "RIGHT", p = m === "RIGHT" || m === "LEFT", T = m === "RIGHT" || m === "DOWN", k = new Map(f.map((t, n) => [t.id, n])), E = new Map(
     (S.positions ?? []).filter((t) => k.has(t.nodeId)).map((t) => [t.nodeId, p ? t.y : t.x])
   ), w = (t, n) => k.get(t) - k.get(n) || t.localeCompare(n), I = (t, n) => (E.get(t) ?? 1 / 0) - (E.get(n) ?? 1 / 0) || w(t, n), x = new Map(f.map((t) => [t.id, /* @__PURE__ */ new Set()]));
-  for (const t of i.edges) {
+  for (const t of s.edges) {
     const n = y(t.source, void 0)?.id, r = y(t.target, void 0)?.id;
     n && r && n !== r && (x.get(n)?.add(r), x.get(r)?.add(n));
   }
@@ -118,25 +118,25 @@ function z(f, i, S, y, O) {
         r.has(l) || (r.set(l, r.get(h) + 1), u.set(l, u.get(h)), c.push(l));
     }
   }
-  const d = Math.max(G.length, e), s = Array.from({ length: d }, () => []);
-  for (const t of f) s[u.get(t.id)].push(t);
-  for (const t of s) t.sort((n, r) => I(n.id, r.id));
+  const d = Math.max(G.length, e), i = Array.from({ length: d }, () => []);
+  for (const t of f) i[u.get(t.id)].push(t);
+  for (const t of i) t.sort((n, r) => I(n.id, r.id));
   const v = (t, n) => {
-    const r = new Map(s[n].map((h, l) => [h.id, l])), c = new Map(s[t].map((h, l) => [h.id, l])), g = (h) => {
+    const r = new Map(i[n].map((h, l) => [h.id, l])), c = new Map(i[t].map((h, l) => [h.id, l])), g = (h) => {
       const l = [...x.get(h) ?? []].flatMap((N) => {
         const b = r.get(N);
         return u.get(N) === n && b !== void 0 ? [b] : [];
       });
       return l.length ? l.reduce((N, b) => N + b, 0) / l.length : c.get(h);
     };
-    s[t].sort((h, l) => g(h.id) - g(l.id) || I(h.id, l.id));
+    i[t].sort((h, l) => g(h.id) - g(l.id) || I(h.id, l.id));
   };
-  for (let t = 1; t < s.length; t++) v(t, t - 1);
-  for (let t = s.length - 2; t >= 0; t--) v(t, t + 1);
+  for (let t = 1; t < i.length; t++) v(t, t - 1);
+  for (let t = i.length - 2; t >= 0; t--) v(t, t + 1);
   const o = S.spacing ?? 64;
   let a = 0, M = 0;
   const H = [], L = [];
-  for (const t of s) {
+  for (const t of i) {
     let n = 0;
     const r = Math.max(0, ...t.map((c) => p ? c.width : c.height));
     H.push(a), L.push(r);

package/dist/components/graph/positions.js

@@ -1,75 +1,76 @@
-import { routeGraphGeometry as G } from "./routing.js";
-function E(d, p, v) {
-  if (!p.positions?.length || p.positionMode === "compact") return d;
-  const f = new Map(d.nodes.map((t) => [t.id, { ...t }])), l = /* @__PURE__ */ new Map();
-  for (const t of p.positions) {
-    if (!f.has(t.nodeId) || l.has(t.nodeId) || !Number.isFinite(t.x) || !Number.isFinite(t.y))
+import { routeGraphGeometry as v } from "./routing.js";
+function C(l, x, G) {
+  if (!x.positions?.length || x.positionMode === "compact")
+    return x.edgeClearance === void 0 ? l : v(l, x);
+  const f = new Map(l.nodes.map((t) => [t.id, { ...t }])), M = /* @__PURE__ */ new Map();
+  for (const t of x.positions) {
+    if (!f.has(t.nodeId) || M.has(t.nodeId) || !Number.isFinite(t.x) || !Number.isFinite(t.y))
       throw new Error(`Invalid graph position: ${t.nodeId}`);
-    l.set(t.nodeId, t);
+    M.set(t.nodeId, t);
   }
   const y = /* @__PURE__ */ new Map();
   for (const t of f.values())
     if (t.parentId) {
-      const m = y.get(t.parentId) ?? [];
-      m.push(t), y.set(t.parentId, m);
+      const c = y.get(t.parentId) ?? [];
+      c.push(t), y.set(t.parentId, c);
     }
-  const x = p.groupPadding ?? { top: 64, left: 28, right: 28, bottom: 28 }, u = p.positionMode === "preferred", I = new Map(v.map((t) => [t.id, t])), b = (t, m, M) => {
-    const g = { x: t.x, y: t.y }, c = l.get(t.id);
-    t.x = c?.x ?? t.x + m, t.y = c?.y ?? t.y + M;
+  const m = x.groupPadding ?? { top: 64, left: 28, right: 28, bottom: 28 }, u = x.positionMode === "preferred", I = new Map(G.map((t) => [t.id, t])), b = (t, c, d) => {
+    const g = { x: t.x, y: t.y }, p = M.get(t.id);
+    t.x = p?.x ?? t.x + c, t.y = p?.y ?? t.y + d;
     const i = y.get(t.id) ?? [];
-    for (const a of i) b(a, t.x - g.x, t.y - g.y);
+    for (const o of i) b(o, t.x - g.x, t.y - g.y);
     if (!i.length || u) return;
-    const r = Math.min(...i.map((a) => a.x)) - x.left, h = Math.min(...i.map((a) => a.y)) - x.top;
-    if (c && (r < t.x || h < t.y))
+    const a = Math.min(...i.map((o) => o.x)) - m.left, h = Math.min(...i.map((o) => o.y)) - m.top;
+    if (p && (a < t.x || h < t.y))
       throw new Error(`Pinned child lies outside group content: ${t.id}`);
-    const s = Math.max(
+    const e = Math.max(
       t.x + t.width,
-      ...i.map((a) => a.x + a.width + x.right)
+      ...i.map((o) => o.x + o.width + m.right)
     ), n = Math.max(
       t.y + t.height,
-      ...i.map((a) => a.y + a.height + x.bottom)
+      ...i.map((o) => o.y + o.height + m.bottom)
     );
-    c || (t.x = Math.min(t.x, r), t.y = Math.min(t.y, h)), t.width = s - t.x, t.height = n - t.y;
+    p || (t.x = Math.min(t.x, a), t.y = Math.min(t.y, h)), t.width = e - t.x, t.height = n - t.y;
   };
   for (const t of f.values()) t.parentId || b(t, 0, 0);
   if (u) {
-    const t = Math.max(16, p.spacing ?? 64), m = (i, r, h) => {
-      i.x += r, i.y += h;
-      for (const s of y.get(i.id) ?? []) m(s, r, h);
-    }, M = (i) => {
-      const r = [];
+    const t = Math.max(16, x.spacing ?? 64), c = (i, a, h) => {
+      i.x += a, i.y += h;
+      for (const e of y.get(i.id) ?? []) c(e, a, h);
+    }, d = (i) => {
+      const a = [];
       for (const h of [...i].sort(
-        (s, n) => s.y - n.y || s.x - n.x || s.id.localeCompare(n.id)
+        (e, n) => e.y - n.y || e.x - n.x || e.id.localeCompare(n.id)
       )) {
-        const s = { x: h.x, y: h.y };
-        for (const o of [...r].sort((e, w) => e.x - w.x))
-          h.y < o.y + o.height + t && h.y + h.height + t > o.y && s.x < o.x + o.width + t && s.x + h.width + t > o.x && (s.x = o.x + o.width + t);
+        const e = { x: h.x, y: h.y };
+        for (const r of [...a].sort((s, w) => s.x - w.x))
+          h.y < r.y + r.height + t && h.y + h.height + t > r.y && e.x < r.x + r.width + t && e.x + h.width + t > r.x && (e.x = r.x + r.width + t);
         const n = { x: h.x, y: h.y };
-        for (const o of [...r].sort((e, w) => e.y - w.y))
-          h.x < o.x + o.width + t && h.x + h.width + t > o.x && n.y < o.y + o.height + t && n.y + h.height + t > o.y && (n.y = o.y + o.height + t);
-        const a = s.x - h.x < n.y - h.y ? s : n;
-        m(h, a.x - h.x, a.y - h.y), r.push(h);
+        for (const r of [...a].sort((s, w) => s.y - w.y))
+          h.x < r.x + r.width + t && h.x + h.width + t > r.x && n.y < r.y + r.height + t && n.y + h.height + t > r.y && (n.y = r.y + r.height + t);
+        const o = e.x - h.x < n.y - h.y ? e : n;
+        c(h, o.x - h.x, o.y - h.y), a.push(h);
       }
     }, g = (i) => {
-      const r = y.get(i.id) ?? [];
-      if (!r.length) return;
-      for (const e of r) g(e);
-      M(r);
-      const h = Math.max(12, x.left), s = Math.max(12, x.top), n = Math.max(12, x.right), a = Math.max(12, x.bottom), o = l.get(i.id);
-      i.x = Math.min(o?.x ?? 1 / 0, Math.min(...r.map((e) => e.x)) - h), i.y = Math.min(o?.y ?? 1 / 0, Math.min(...r.map((e) => e.y)) - s), i.width = Math.max(
+      const a = y.get(i.id) ?? [];
+      if (!a.length) return;
+      for (const s of a) g(s);
+      d(a);
+      const h = Math.max(12, m.left), e = Math.max(12, m.top), n = Math.max(12, m.right), o = Math.max(12, m.bottom), r = M.get(i.id);
+      i.x = Math.min(r?.x ?? 1 / 0, Math.min(...a.map((s) => s.x)) - h), i.y = Math.min(r?.y ?? 1 / 0, Math.min(...a.map((s) => s.y)) - e), i.width = Math.max(
         I.get(i.id).width,
-        Math.max(...r.map((e) => e.x + e.width)) + n - i.x
+        Math.max(...a.map((s) => s.x + s.width)) + n - i.x
       ), i.height = Math.max(
         I.get(i.id).height,
-        Math.max(...r.map((e) => e.y + e.height)) + a - i.y
+        Math.max(...a.map((s) => s.y + s.height)) + o - i.y
       );
-    }, c = [...f.values()].filter((i) => !i.parentId);
-    for (const i of c) g(i);
-    M(c);
+    }, p = [...f.values()].filter((i) => !i.parentId);
+    for (const i of p) g(i);
+    d(p);
   }
-  return G({ ...d, nodes: [...f.values()] });
+  return v({ ...l, nodes: [...f.values()] }, x);
 }
 export {
-  E as applyGraphPositions,
-  G as routeGraphGeometry
+  C as applyGraphPositions,
+  v as routeGraphGeometry
 };

package/dist/components/graph/routing.d.ts

@@ -1,3 +1,3 @@
-import type { GraphLayout } from './types';
+import type { GraphLayout, GraphLayoutOptions } from './types';
 /** Joint orthogonal routing through the final rectangular geometry. */
-export declare function routeGraphGeometry(layout: GraphLayout): Promise<GraphLayout>;
+export declare function routeGraphGeometry(layout: GraphLayout, options?: Pick<GraphLayoutOptions, 'edgeClearance'>): Promise<GraphLayout>;

package/dist/components/graph/routing.js

@@ -1,240 +1,242 @@
-import { AvoidLib as G } from "../../node_modules/.pnpm/libavoid-js@0.5.0-beta.5/node_modules/libavoid-js/dist/index.js";
-import V from "../../node_modules/.pnpm/libavoid-js@0.5.0-beta.5/node_modules/libavoid-js/dist/libavoid.wasm.js";
-let J;
-const j = { NORTH: 1, SOUTH: 2, WEST: 4, EAST: 8 }, N = ["NORTH", "EAST", "SOUTH", "WEST"], O = (n) => n.delete();
-async function $(n) {
+import { AvoidLib as Y } from "../../node_modules/.pnpm/libavoid-js@0.5.0-beta.5/node_modules/libavoid-js/dist/index.js";
+import tt from "../../node_modules/.pnpm/libavoid-js@0.5.0-beta.5/node_modules/libavoid-js/dist/libavoid.wasm.js";
+let _;
+const L = { NORTH: 1, SOUTH: 2, WEST: 4, EAST: 8 }, A = ["NORTH", "EAST", "SOUTH", "WEST"], S = (n) => n.delete();
+async function et(n, o = {}) {
+  const a = o.edgeClearance ?? 4;
+  if (!Number.isFinite(a) || a < 0)
+    throw new Error("Graph edge clearance must be finite and nonnegative");
   if (!n.nodes.length) return n;
-  if (!n.edges.length) return F(n);
-  await (J ??= G.load(V).catch((y) => {
-    throw J = void 0, y;
+  if (!n.edges.length) return $(n);
+  await (_ ??= Y.load(tt).catch((r) => {
+    throw _ = void 0, r;
   }));
-  const s = G.getInstance(), r = new Map(n.nodes.map((y) => [y.id, y])), p = (y) => {
-    const m = [];
-    for (let i = r.get(y).parentId; i; i = r.get(i).parentId)
-      m.push(i);
-    return m;
-  }, x = /* @__PURE__ */ new Map();
-  for (const y of n.edges) {
-    const m = /* @__PURE__ */ new Set([...p(y.source), ...p(y.target)]), i = JSON.stringify([...m].sort()), e = x.get(i) ?? { open: m, edges: [] };
-    e.edges.push(y), x.set(i, e);
+  const i = Y.getInstance(), h = new Map(n.nodes.map((r) => [r.id, r])), l = (r) => {
+    const c = [];
+    for (let s = h.get(r).parentId; s; s = h.get(s).parentId)
+      c.push(s);
+    return c;
+  }, f = /* @__PURE__ */ new Map();
+  for (const r of n.edges) {
+    const c = /* @__PURE__ */ new Set([...l(r.source), ...l(r.target)]), s = JSON.stringify([...c].sort()), M = f.get(s) ?? { open: c, edges: [] };
+    M.edges.push(r), f.set(s, M);
   }
   const T = /* @__PURE__ */ new Map();
-  for (const { open: y, edges: m } of x.values()) {
-    const i = new s.Router(2);
+  for (const { open: r, edges: c } of f.values()) {
+    const s = new i.Router(2);
     try {
-      i.setRoutingParameter(s.RoutingParameter.shapeBufferDistance, 4), i.setRoutingParameter(s.RoutingParameter.idealNudgingDistance, 8), i.setRoutingParameter(s.RoutingParameter.crossingPenalty, 80), i.setRoutingParameter(s.RoutingParameter.fixedSharedPathPenalty, 120), i.setRoutingParameter(s.RoutingParameter.portDirectionPenalty, 0), i.setRoutingOption(s.RoutingOption.nudgeOrthogonalSegmentsConnectedToShapes, !1), i.setRoutingOption(s.RoutingOption.nudgeSharedPathsWithCommonEndPoint, !0);
-      const e = new Map(
-        n.nodes.filter((t) => !y.has(t.id) && p(t.id).every((o) => y.has(o))).map((t) => {
-          const o = new s.Point(t.x, t.y), g = new s.Point(t.x + t.width, t.y + t.height), a = new s.Rectangle(o, g), h = new s.ShapeRef(i, a);
-          return O(o), O(g), O(a), [t.id, h];
+      s.setRoutingParameter(i.RoutingParameter.shapeBufferDistance, a), s.setRoutingParameter(i.RoutingParameter.idealNudgingDistance, 8), s.setRoutingParameter(i.RoutingParameter.crossingPenalty, 80), s.setRoutingParameter(i.RoutingParameter.fixedSharedPathPenalty, 120), s.setRoutingParameter(i.RoutingParameter.portDirectionPenalty, 0), s.setRoutingOption(i.RoutingOption.nudgeOrthogonalSegmentsConnectedToShapes, !1), s.setRoutingOption(i.RoutingOption.nudgeSharedPathsWithCommonEndPoint, !0);
+      const M = new Map(
+        n.nodes.filter((t) => !r.has(t.id) && l(t.id).every((e) => r.has(e))).map((t) => {
+          const e = new i.Point(t.x, t.y), g = new i.Point(t.x + t.width, t.y + t.height), p = new i.Rectangle(e, g), x = new i.ShapeRef(s, p);
+          return S(e), S(g), S(p), [t.id, x];
         })
-      ), c = /* @__PURE__ */ new Map(), S = n.nodes.filter((t) => e.has(t.id)), E = /* @__PURE__ */ new Map();
-      m.forEach((t) => {
-        const o = r.get(t.source), g = r.get(t.target), a = Y(o, g), h = t.sourcePort ? o.ports.find((P) => P.id === t.sourcePort).side : t.targetPort ? B(g.ports.find((P) => P.id === t.targetPort).side) : a.source, u = t.targetPort ? g.ports.find((P) => P.id === t.targetPort).side : t.sourcePort ? B(o.ports.find((P) => P.id === t.sourcePort).side) : a.target, d = [t.source, t.target].sort().join("\0"), f = E.get(d) ?? 0;
-        E.set(d, f + 1);
-        const M = f % 2 === 0 ? -6 : 6, R = t.source === t.target ? void 0 : X(
-          o,
-          g,
-          S,
-          a,
-          M,
-          t.sourcePort ? h : void 0,
-          t.targetPort ? u : void 0
-        );
-        c.set(t.id, {
-          sourceSide: R?.source ?? h,
-          targetSide: R?.target ?? u,
-          offset: M
-        });
-      });
-      let l = N.length + 2;
-      const A = /* @__PURE__ */ new Map(), C = (t, o) => Math.max(0, Math.min(1, t / o));
+      ), O = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Map();
+      for (const t of c) {
+        const e = [t.source, t.target].sort().join("\0"), g = O.get(e) ?? 0;
+        O.set(e, g + 1), E.set(t.id, g % 2 === 0 ? -6 : 6);
+      }
+      let Q = A.length + 2;
+      const B = /* @__PURE__ */ new Map(), b = (t, e) => Math.max(0, Math.min(1, t / e));
       for (const t of n.nodes) {
-        const o = e.get(t.id);
-        if (!o) continue;
-        const g = (a, h, u, d, f) => {
-          const M = new s.ShapeConnectionPin(
-            o,
-            a,
-            C(h, t.width),
-            C(u, t.height),
+        const e = M.get(t.id);
+        if (!e) continue;
+        const g = (p, x, w, y, m) => {
+          const N = new i.ShapeConnectionPin(
+            e,
+            p,
+            b(x, t.width),
+            b(w, t.height),
             !0,
             0,
-            d
+            y
           );
-          M.setExclusive(f), M.setConnectionCost(
-            t.width / 2 + t.height / 2 - Math.abs(h - t.width / 2) - Math.abs(u - t.height / 2)
+          N.setExclusive(m), N.setConnectionCost(
+            t.width / 2 + t.height / 2 - Math.abs(x - t.width / 2) - Math.abs(w - t.height / 2)
           );
         };
-        for (const a of new Set(t.ports?.map((h) => h.side))) {
-          const { x: h, y: u } = U(t, a), d = N.indexOf(a) + 2;
-          g(d, h - t.x, u - t.y, j[a], !1), A.set(
+        for (const p of new Set(t.ports?.map((x) => x.side))) {
+          const { x, y: w } = q(t, p), y = A.indexOf(p) + 2;
+          g(y, x - t.x, w - t.y, L[p], !1), B.set(
             JSON.stringify([
               t.id,
-              C(h - t.x, t.width),
-              C(u - t.y, t.height),
-              a
+              b(x - t.x, t.width),
+              b(w - t.y, t.height),
+              p
             ]),
-            d
+            y
           );
         }
       }
-      const H = (t, o, g, a) => {
-        const h = r.get(t), u = e.get(t);
-        if (u && o)
-          return new s.ConnEnd(
-            u,
-            N.indexOf(h.ports.find((R) => R.id === o).side) + 2
+      const F = /* @__PURE__ */ new Map(), Z = n.nodes.filter((t) => M.has(t.id)), J = (t, e, g, p, x, w = !1) => {
+        const y = M.get(t.id);
+        if (y && g)
+          return new i.ConnEnd(
+            y,
+            A.indexOf(t.ports.find((d) => d.id === g).side) + 2
           );
-        if (u) {
-          const R = C(g.x - h.x, h.width), P = C(g.y - h.y, h.height), b = JSON.stringify([t, R, P, a]), D = A.get(b);
-          if (D !== void 0) return new s.ConnEnd(u, D);
-          const k = l++;
-          return A.set(b, k), new s.ShapeConnectionPin(
-            u,
-            k,
-            R,
-            P,
-            !0,
-            0,
-            j[a]
-          ).setExclusive(!1), new s.ConnEnd(u, k);
+        const m = g ? [
+          {
+            side: t.ports.find((d) => d.id === g).side,
+            position: q(t, t.ports.find((d) => d.id === g).side)
+          }
+        ] : x ? [{ side: "EAST", position: x }] : (w ? [K(t, e).source] : A).flatMap((d) => {
+          const P = nt(t, d, e, p);
+          if (w) return [{ side: d, position: P }];
+          const R = d === "NORTH" || d === "SOUTH", H = R ? t.x : t.y, v = R ? t.width : t.height, C = H + Math.min(8, v / 4), j = H + v - Math.min(8, v / 4);
+          return [
+            R ? P.x : P.y,
+            C,
+            j,
+            ...Z.flatMap((u) => {
+              const k = R ? u.x : u.y, X = k + (R ? u.width : u.height);
+              return [k - a, X + a, k - a - 8, X + a + 8];
+            }).filter((u) => u >= C && u <= j)
+          ].map((u) => ({
+            side: d,
+            position: R ? { x: u, y: P.y } : { x: P.x, y: u }
+          }));
+        });
+        if (y) {
+          const d = (v, C) => JSON.stringify([
+            t.id,
+            b(C.x - t.x, t.width),
+            b(C.y - t.y, t.height),
+            v
+          ]), P = !!(g || x || w), R = P ? B.get(d(m[0].side, m[0].position)) : F.get(t.id);
+          if (P && R !== void 0) return new i.ConnEnd(y, R);
+          const H = R ?? Q++;
+          P || F.set(t.id, H);
+          for (const { side: v, position: C } of m) {
+            const j = d(v, C);
+            if (B.has(j)) continue;
+            B.set(j, H);
+            const D = C.x - t.x, u = C.y - t.y, k = new i.ShapeConnectionPin(
+              y,
+              H,
+              b(D, t.width),
+              b(u, t.height),
+              !0,
+              0,
+              L[v]
+            );
+            k.setExclusive(!1), k.setConnectionCost(
+              t.width / 2 + t.height / 2 - Math.abs(D - t.width / 2) - Math.abs(u - t.height / 2)
+            );
+          }
+          return new i.ConnEnd(y, H);
         }
-        const d = o ? U(h, h.ports.find((R) => R.id === o).side) : g, f = new s.Point(d.x, d.y), M = new s.ConnEnd(f);
-        return O(f), M;
-      }, v = m.map((t) => {
-        const o = r.get(t.source), g = r.get(t.target), a = c.get(t.id), h = H(
-          t.source,
+        const N = K(t, e).source, G = m.find((d) => d.side === N)?.position ?? m[0].position, W = new i.Point(G.x, G.y), z = new i.ConnEnd(W);
+        return S(W), z;
+      }, V = (t) => +!!(t.sourcePort || t.targetPort || t.source === t.target || O.get([t.source, t.target].sort().join("\0")) > 1), I = [...c].sort((t, e) => V(e) - V(t)).map((t) => {
+        const e = h.get(t.source), g = h.get(t.target), p = t.source === t.target, x = O.get([t.source, t.target].sort().join("\0")) > 1, w = J(
+          e,
+          g,
           t.sourcePort,
-          t.source === t.target ? { x: o.x + o.width, y: o.y + o.height / 3 } : W(o, a.sourceSide, g, a.offset),
-          t.source === t.target ? "EAST" : a.sourceSide
-        ), u = H(
-          t.target,
+          E.get(t.id),
+          p ? { x: e.x + e.width, y: e.y + e.height / 3 } : void 0,
+          x
+        ), y = J(
+          g,
+          e,
           t.targetPort,
-          t.source === t.target ? {
+          E.get(t.id),
+          p ? {
             x: g.x + g.width,
             y: g.y + g.height * 2 / 3
-          } : W(g, a.targetSide, o, a.offset),
-          t.source === t.target ? "EAST" : a.targetSide
-        ), d = new s.ConnRef(i, h, u);
-        if (O(h), O(u), t.source === t.target) {
-          const f = r.get(t.source), M = new s.CheckpointVector();
-          for (const R of [f.y + f.height / 3, f.y + f.height * 2 / 3]) {
-            const P = new s.Point(f.x + f.width + 24, R), b = new s.Checkpoint(P);
-            M.push_back(b), O(P), O(b);
+          } : void 0,
+          x
+        ), m = new i.ConnRef(s, w, y);
+        if (S(w), S(y), p) {
+          const N = new i.CheckpointVector();
+          for (const G of [
+            e.y + e.height / 3,
+            e.y + e.height * 2 / 3
+          ]) {
+            const W = new i.Point(
+              e.x + e.width + Math.max(24, a + 4),
+              G
+            ), z = new i.Checkpoint(W);
+            N.push_back(z), S(W), S(z);
           }
-          d.setRoutingCheckpoints(M), O(M);
+          m.setRoutingCheckpoints(N), S(N);
         }
-        return { edge: t, connection: d };
+        return { edge: t, connection: m };
       });
-      i.processTransaction();
-      for (const { edge: t, connection: o } of v) {
-        const g = o.displayRoute(), a = Array.from({ length: g.size() }, (h, u) => {
-          const d = g.at(u), f = { x: d.x, y: d.y };
-          return O(d), f;
+      s.processTransaction();
+      for (const { edge: t, connection: e } of I) {
+        const g = e.displayRoute(), p = Array.from({ length: g.size() }, (x, w) => {
+          const y = g.at(w), m = { x: y.x, y: y.y };
+          return S(y), m;
         });
-        if (O(g), !o.hasValidRoute() || a.length < 2 || a.some((h) => !Number.isFinite(h.x) || !Number.isFinite(h.y)) || a.some((h, u) => u > 0 && h.x !== a[u - 1].x && h.y !== a[u - 1].y))
+        if (S(g), !e.hasValidRoute() || p.length < 2 || p.some((x) => !Number.isFinite(x.x) || !Number.isFinite(x.y)) || p.some((x, w) => w > 0 && x.x !== p[w - 1].x && x.y !== p[w - 1].y))
           throw new Error(`Graph edge cannot be routed: ${t.id}`);
-        T.set(t.id, a);
+        T.set(t.id, p);
       }
     } finally {
-      i.delete();
+      s.delete();
     }
   }
-  const w = n.edges.map((y) => ({ ...y, sections: [T.get(y.id)] }));
-  return F({
+  const U = n.edges.map((r) => ({ ...r, sections: [T.get(r.id)] }));
+  return $({
     nodes: n.nodes,
-    edges: w,
+    edges: U,
     bounds: n.bounds
   });
 }
-function F(n) {
-  const s = [
-    ...n.nodes.flatMap((x) => [
-      { x: x.x, y: x.y },
-      { x: x.x + x.width, y: x.y + x.height }
+function $(n) {
+  const o = [
+    ...n.nodes.flatMap((h) => [
+      { x: h.x, y: h.y },
+      { x: h.x + h.width, y: h.y + h.height }
     ]),
-    ...n.edges.flatMap((x) => x.sections.flat())
-  ], r = Math.min(...s.map((x) => x.x)), p = Math.min(...s.map((x) => x.y));
+    ...n.edges.flatMap((h) => h.sections.flat())
+  ], a = Math.min(...o.map((h) => h.x)), i = Math.min(...o.map((h) => h.y));
   return {
     nodes: n.nodes,
     edges: n.edges,
     bounds: {
-      x: r,
-      y: p,
-      width: Math.max(...s.map((x) => x.x)) - r,
-      height: Math.max(...s.map((x) => x.y)) - p
+      x: a,
+      y: i,
+      width: Math.max(...o.map((h) => h.x)) - a,
+      height: Math.max(...o.map((h) => h.y)) - i
     }
   };
 }
-function U(n, s) {
+function q(n, o) {
   return {
-    x: s === "WEST" ? n.x : s === "EAST" ? n.x + n.width : n.x + n.width / 2,
-    y: s === "NORTH" ? n.y : s === "SOUTH" ? n.y + n.height : n.y + n.height / 2
+    x: o === "WEST" ? n.x : o === "EAST" ? n.x + n.width : n.x + n.width / 2,
+    y: o === "NORTH" ? n.y : o === "SOUTH" ? n.y + n.height : n.y + n.height / 2
   };
 }
-function B(n) {
-  return {
-    NORTH: "SOUTH",
-    EAST: "WEST",
-    SOUTH: "NORTH",
-    WEST: "EAST"
-  }[n];
-}
-function X(n, s, r, p, x, T, w) {
-  let y;
-  const m = (i, e, c) => c === "NORTH" ? e.x === i.x && e.y < i.y : c === "SOUTH" ? e.x === i.x && e.y > i.y : c === "WEST" ? e.y === i.y && e.x < i.x : e.y === i.y && e.x > i.x;
-  for (const i of T ? [T] : N)
-    for (const e of w ? [w] : N) {
-      const c = T ? U(n, i) : W(n, i, s, x), S = w ? U(s, e) : W(s, e, n, x), E = c.x === S.x || c.y === S.y ? [[c, S]] : [
-        [c, { x: S.x, y: c.y }, S],
-        [c, { x: c.x, y: S.y }, S]
-      ];
-      for (const l of E) {
-        if (r.includes(n) && !m(c, l[1], i) || r.includes(s) && !m(S, l.at(-2), e) || l.slice(1).some((H, v) => {
-          const t = l[v];
-          return r.some(
-            (o) => Math.max(t.x, H.x) > o.x && Math.min(t.x, H.x) < o.x + o.width && Math.max(t.y, H.y) > o.y && Math.min(t.y, H.y) < o.y + o.height
-          );
-        }))
-          continue;
-        const C = l.slice(1).reduce(
-          (H, v, t) => H + Math.abs(v.x - l[t].x) + Math.abs(v.y - l[t].y),
-          0
-        ) + (l.length - 2) * 32 + (i === p.source ? 0 : 16) + (e === p.target ? 0 : 16);
-        (!y || C < y.score) && (y = { source: i, target: e, score: C });
-      }
-    }
-  return y;
-}
-function Y(n, s) {
-  const r = (e, c) => c.x >= e.x && c.y >= e.y && c.x + c.width <= e.x + e.width && c.y + c.height <= e.y + e.height, p = r(n, s) ? n : r(s, n) ? s : void 0;
-  if (p) {
-    const e = p === n ? s : n, c = {
-      NORTH: e.y - p.y,
-      EAST: p.x + p.width - e.x - e.width,
-      SOUTH: p.y + p.height - e.y - e.height,
-      WEST: e.x - p.x
-    }, S = [...N].sort((E, l) => c[E] - c[l])[0];
-    return { source: S, target: S };
+function K(n, o) {
+  const a = (c, s) => s.x >= c.x && s.y >= c.y && s.x + s.width <= c.x + c.width && s.y + s.height <= c.y + c.height, i = a(n, o) ? n : a(o, n) ? o : void 0;
+  if (i) {
+    const c = i === n ? o : n, s = {
+      NORTH: c.y - i.y,
+      EAST: i.x + i.width - c.x - c.width,
+      SOUTH: i.y + i.height - c.y - c.height,
+      WEST: c.x - i.x
+    }, M = [...A].sort((O, E) => s[O] - s[E])[0];
+    return { source: M, target: M };
   }
-  const x = s.x + s.width / 2 - (n.x + n.width / 2), T = s.y + s.height / 2 - (n.y + n.height / 2), w = Math.max(n.x - (s.x + s.width), s.x - (n.x + n.width), 0), y = Math.max(
-    n.y - (s.y + s.height),
-    s.y - (n.y + n.height),
+  const h = o.x + o.width / 2 - (n.x + n.width / 2), l = o.y + o.height / 2 - (n.y + n.height / 2), f = Math.max(n.x - (o.x + o.width), o.x - (n.x + n.width), 0), T = Math.max(
+    n.y - (o.y + o.height),
+    o.y - (n.y + n.height),
     0
-  ), i = (y === 0 && w > 0 ? !0 : w === 0 && y > 0 ? !1 : w === 0 && y === 0 ? Math.abs(x) >= Math.abs(T) : w <= y) ? x >= 0 ? "EAST" : "WEST" : T >= 0 ? "SOUTH" : "NORTH";
-  return { source: i, target: B(i) };
+  ), r = (T === 0 && f > 0 ? !0 : f === 0 && T > 0 ? !1 : f === 0 && T === 0 ? Math.abs(h) >= Math.abs(l) : f <= T) ? h >= 0 ? "EAST" : "WEST" : l >= 0 ? "SOUTH" : "NORTH";
+  return { source: r, target: A[(A.indexOf(r) + 2) % 4] };
 }
-function W(n, s, r, p = 0) {
-  const x = (i) => Math.min(8, i / 4), T = (i, e, c) => Math.max(e + x(c), Math.min(e + c - x(c), i)), w = (i, e, c, S) => {
-    const E = Math.max(i, c), l = Math.min(i + e, c + S);
-    return E < l ? (E + l) / 2 + p : void 0;
-  }, y = r.x + r.width / 2, m = r.y + r.height / 2;
-  switch (s) {
+function nt(n, o, a, i = 0) {
+  const h = (r) => Math.min(8, r / 4), l = (r, c, s) => Math.max(c + h(s), Math.min(c + s - h(s), r)), f = (r, c, s, M) => {
+    const O = Math.max(r, s), E = Math.min(r + c, s + M);
+    return O < E ? (O + E) / 2 + i : void 0;
+  }, T = a.x + a.width / 2, U = a.y + a.height / 2;
+  switch (o) {
     case "NORTH":
       return {
-        x: T(
-          w(n.x, n.width, r.x, r.width) ?? y + p,
+        x: l(
+          f(n.x, n.width, a.x, a.width) ?? T + i,
           n.x,
           n.width
         ),
@@ -243,16 +245,16 @@ function W(n, s, r, p = 0) {
     case "EAST":
       return {
         x: n.x + n.width,
-        y: T(
-          w(n.y, n.height, r.y, r.height) ?? m + p,
+        y: l(
+          f(n.y, n.height, a.y, a.height) ?? U + i,
           n.y,
           n.height
         )
       };
     case "SOUTH":
       return {
-        x: T(
-          w(n.x, n.width, r.x, r.width) ?? y + p,
+        x: l(
+          f(n.x, n.width, a.x, a.width) ?? T + i,
           n.x,
           n.width
         ),
@@ -261,8 +263,8 @@ function W(n, s, r, p = 0) {
     case "WEST":
       return {
         x: n.x,
-        y: T(
-          w(n.y, n.height, r.y, r.height) ?? m + p,
+        y: l(
+          f(n.y, n.height, a.y, a.height) ?? U + i,
           n.y,
           n.height
         )
@@ -270,5 +272,5 @@ function W(n, s, r, p = 0) {
   }
 }
 export {
-  $ as routeGraphGeometry
+  et as routeGraphGeometry
 };

package/dist/components/graph/types.d.ts

@@ -46,6 +46,8 @@ export interface GraphLayout {
     bounds: GraphBounds;
 }
 export interface GraphLayoutOptions {
+    /** Clearance around routing obstacles in world units. Defaults to 4; never changes node geometry. */
+    edgeClearance?: number;
     /** Desired width/height when packing disconnected objects, including group members. */
     aspectRatio?: number;
     /** Absolute world positions. Descendants move with their group. Invalid positions always fail. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/floe-webapp-core",
-  "version": "0.86.11",
+  "version": "0.86.13",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",