austere-axi 0.1.0 → 0.2.0

package/dist/cli.mjs

@@ -6,10 +6,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res, err) => function __init() {
+var __esm = (fn2, res, err) => function __init() {
   if (err) throw err[0];
   try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
   } catch (e) {
     throw err = [e], e;
   }
@@ -496,7 +496,7 @@ var require_ci_info = __commonJS({
 function readArtifact(html) {
   const text = String(html);
   const m = PROGRAM_RE.exec(text);
-  const rt = RUNTIME_RE.exec(text);
+  const rt2 = RUNTIME_RE.exec(text);
   const t = TITLE_RE.exec(text);
   let program = null;
   let programStart = -1;
@@ -515,7 +515,7 @@ function readArtifact(html) {
     programStart,
     programEnd,
     programLine,
-    runtimeSrc: rt ? rt[1] : null,
+    runtimeSrc: rt2 ? rt2[1] : null,
     title: t ? decodeEntities(t[1].trim()) : "",
     shell
   };
@@ -605,7 +605,7 @@ var init_paths = __esm({
     HERE = path.dirname(fileURLToPath(import.meta.url));
     BUNDLED = true;
     ASSET_DIR = BUNDLED ? HERE : path.resolve(HERE, "../../dist");
-    VERSION = true ? "0.1.0" : JSON.parse(fs.readFileSync(path.resolve(HERE, "../../package.json"), "utf8")).version;
+    VERSION = true ? "0.2.0" : JSON.parse(fs.readFileSync(path.resolve(HERE, "../../package.json"), "utf8")).version;
     CLI_ENTRY = BUNDLED ? fileURLToPath(import.meta.url) : path.resolve(HERE, "main.js");
   }
 });
@@ -992,7 +992,7 @@ data: ${JSON.stringify(data)}
     const items = [];
     let end = false;
     for (const e of entries) {
-      for (const it of e.items || []) items.push(it);
+      for (const it2 of e.items || []) items.push(it2);
       if (e.end) end = true;
     }
     const body = {
@@ -1170,11 +1170,11 @@ data: ${JSON.stringify(data)}
     const clean = path4.normalize(rel).replace(/^(\.\.[/\\])+/, "");
     const file2 = path4.join(ASSET_DIR, clean);
     if (!file2.startsWith(ASSET_DIR + path4.sep)) return send(res, 404, "not found");
-    fs7.stat(file2, (err, st) => {
-      if (err || !st.isFile()) return send(res, 404, "not found");
+    fs7.stat(file2, (err, st2) => {
+      if (err || !st2.isFile()) return send(res, 404, "not found");
       res.writeHead(200, {
         "content-type": MIME[path4.extname(file2)] || "application/octet-stream",
-        "content-length": st.size,
+        "content-length": st2.size,
         "cache-control": "no-cache",
         "x-content-type-options": "nosniff"
       });
@@ -1200,11 +1200,11 @@ data: ${JSON.stringify(data)}
     if (!file2.startsWith(dir + path4.sep) || decoded.split(/[/\\]/).some((p) => p.startsWith("."))) {
       return send(res, 404, "not found");
     }
-    fs7.stat(file2, (err, st) => {
-      if (err || !st.isFile() || st.size > 64 * 1024 * 1024) return send(res, 404, "not found");
+    fs7.stat(file2, (err, st2) => {
+      if (err || !st2.isFile() || st2.size > 64 * 1024 * 1024) return send(res, 404, "not found");
       res.writeHead(200, {
         "content-type": MIME[path4.extname(file2).toLowerCase()] || "application/octet-stream",
-        "content-length": st.size,
+        "content-length": st2.size,
         "cache-control": "no-cache",
         "x-content-type-options": "nosniff"
       });
@@ -1306,7 +1306,7 @@ data: ${JSON.stringify(snapshot)}
       const items = Array.isArray(body.items) ? body.items.filter((x) => x && typeof x === "object").slice(0, 200) : [];
       if (s.status === "ended") return send(res, 409, { error: "session has ended" });
       if (!items.length && !body.end) return send(res, 400, { error: "nothing to send" });
-      for (const it of items) it.id = it.id || newId("i");
+      for (const it2 of items) it2.id = it2.id || newId("i");
       let entry = null;
       if (items.length) entry = store.addUserBatch(s, items, { end: !!body.end });
       if (body.end) {
@@ -2347,14 +2347,14 @@ function promiseAllObject(promisesObj) {
 }
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str = "";
+  let str2 = "";
   for (let i = 0; i < length; i++) {
-    str += chars[Math.floor(Math.random() * chars.length)];
+    str2 += chars[Math.floor(Math.random() * chars.length)];
   }
-  return str;
+  return str2;
 }
-function esc(str) {
-  return JSON.stringify(str);
+function esc(str2) {
+  return JSON.stringify(str2);
 }
 function slugify(input2) {
   return input2.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -2468,8 +2468,8 @@ var primitiveTypes = /* @__PURE__ */ new Set([
   "symbol",
   "undefined"
 ]);
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str2) {
+  return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function clone(inst, def, params) {
   const cl = new inst._zod.constr(def ?? inst._zod.def);
@@ -2735,13 +2735,13 @@ function getSizableOrigin(input2) {
   return "unknown";
 }
 var highSurrogate = /[\uD800-\uDBFF]/;
-function codePointLength(str) {
-  const units = str.length;
-  if (!highSurrogate.test(str))
+function codePointLength(str2) {
+  const units = str2.length;
+  if (!highSurrogate.test(str2))
     return units;
   let count = units;
   for (let i = 0; i < units - 1; i++) {
-    if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
+    if ((str2.charCodeAt(i) & 64512) === 55296 && (str2.charCodeAt(i + 1) & 64512) === 56320) {
       count--;
       i++;
     }
@@ -2867,11 +2867,11 @@ function derived(computes, table) {
   }
   return table;
 }
-function defineBound(proto, key, fn) {
+function defineBound(proto, key, fn2) {
   Object.defineProperty(proto, key, {
     configurable: true,
     get() {
-      return this == null ? fn : own(this, key, fn.bind(this));
+      return this == null ? fn2 : own(this, key, fn2.bind(this));
     },
     set(value) {
       own(this, key, value);
@@ -2943,9 +2943,9 @@ function installLazyProp(inst, key, make, enumerable) {
 }
 var CONSTANT_CATCH = "~constantCatch";
 function constantCatch(value) {
-  const fn = () => value;
-  fn[CONSTANT_CATCH] = true;
-  return fn;
+  const fn2 = () => value;
+  fn2[CONSTANT_CATCH] = true;
+  return fn2;
 }
 
 // node_modules/zod/v4/core/core.js
@@ -3029,8 +3029,8 @@ function $constructor(name, initializer3, proto, params) {
     init(inst, def);
     const deferred = inst._zod.deferred;
     if (deferred) {
-      for (const fn of deferred) {
-        fn();
+      for (const fn2 of deferred) {
+        fn2();
       }
       inst._zod.deferred = void 0;
     }
@@ -3267,7 +3267,7 @@ function finalizeParams(callee, params) {
   return { callee: params?.callee ?? callee, Err: params?.Err };
 }
 var _parse = (_Err) => {
-  const fn = (schema, value, _ctx, _params) => {
+  const fn2 = (schema, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
     const result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise) {
@@ -3275,28 +3275,28 @@ var _parse = (_Err) => {
     }
     if (result.issues.length) {
       const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
-      captureStackTrace(e, _params?.callee ?? fn);
+      captureStackTrace(e, _params?.callee ?? fn2);
       throw e;
     }
     return result.value;
   };
-  return fn;
+  return fn2;
 };
 var parse = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => {
-  const fn = async (schema, value, _ctx, params) => {
+  const fn2 = async (schema, value, _ctx, params) => {
     const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
     if (result instanceof Promise)
       result = await result;
     if (result.issues.length) {
       const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
-      captureStackTrace(e, params?.callee ?? fn);
+      captureStackTrace(e, params?.callee ?? fn2);
       throw e;
     }
     return result.value;
   };
-  return fn;
+  return fn2;
 };
 var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
 var _safeParse = (_Err) => (schema, value, _ctx) => {
@@ -3371,36 +3371,36 @@ var validateAsync = async (schema, value, _ctx) => {
 };
 var _encode = (_Err) => {
   const parse4 = _parse(_Err);
-  const fn = (schema, value, _ctx, _params) => {
+  const fn2 = (schema, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return parse4(schema, value, ctx, finalizeParams(fn, _params));
+    return parse4(schema, value, ctx, finalizeParams(fn2, _params));
   };
-  return fn;
+  return fn2;
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
 var _decode = (_Err) => {
   const parse4 = _parse(_Err);
-  const fn = (schema, value, _ctx, _params) => {
-    return parse4(schema, value, _ctx, finalizeParams(fn, _params));
+  const fn2 = (schema, value, _ctx, _params) => {
+    return parse4(schema, value, _ctx, finalizeParams(fn2, _params));
   };
-  return fn;
+  return fn2;
 };
 var decode = /* @__PURE__ */ _decode($ZodRealError);
 var _encodeAsync = (_Err) => {
   const parseAsync3 = _parseAsync(_Err);
-  const fn = async (schema, value, _ctx, _params) => {
+  const fn2 = async (schema, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return await parseAsync3(schema, value, ctx, finalizeParams(fn, _params));
+    return await parseAsync3(schema, value, ctx, finalizeParams(fn2, _params));
   };
-  return fn;
+  return fn2;
 };
 var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
 var _decodeAsync = (_Err) => {
   const parseAsync3 = _parseAsync(_Err);
-  const fn = async (schema, value, _ctx, _params) => {
-    return await parseAsync3(schema, value, _ctx, finalizeParams(fn, _params));
+  const fn2 = async (schema, value, _ctx, _params) => {
+    return await parseAsync3(schema, value, _ctx, finalizeParams(fn2, _params));
   };
-  return fn;
+  return fn2;
 };
 var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
 var _safeEncode = (_Err) => (schema, value, _ctx) => {
@@ -4079,10 +4079,10 @@ var Doc = class {
     this.closed = closed;
   }
   // the compiler catches a child's throw and keeps writing into this doc, so the indent has to unwind with it
-  indented(fn) {
+  indented(fn2) {
     this.indent += 1;
     try {
-      fn(this);
+      fn2(this);
     } finally {
       this.indent -= 1;
     }
@@ -4128,8 +4128,8 @@ var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
   const defChecks = inst._zod.def.checks;
   const checks = inst._zod.traits.has("$ZodCheck") ? [inst, ...defChecks ?? []] : defChecks?.length ? [...defChecks] : [];
   for (const ch of checks) {
-    for (const fn of ch._zod.onattach) {
-      fn(inst);
+    for (const fn2 of ch._zod.onattach) {
+      fn2(inst);
     }
   }
   if (checks.length === 0) {
@@ -5628,8 +5628,8 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     for (let i = 0; i < items.length; i++) {
       const r = items[i]._zod.run({ value: input2[i], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((rr) => {
-          itemResults[i] = rr;
+        proms.push(r.then((rr2) => {
+          itemResults[i] = rr2;
         }));
       } else {
         itemResults[i] = r;
@@ -9351,11 +9351,11 @@ var error20 = () => {
           return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
         }
         const adj = issue2.inclusive ? "<=" : "<";
-        const be = verbFor(issue2.origin ?? "value");
+        const be2 = verbFor(issue2.origin ?? "value");
         if (sizing?.unit) {
-          return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
+          return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be2} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
         }
-        return `${sizing?.longLabel ?? "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()}`;
+        return `${sizing?.longLabel ?? "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be2} ${adj}${issue2.maximum.toString()}`;
       }
       case "too_small": {
         const sizing = getSizing(issue2.origin);
@@ -9377,11 +9377,11 @@ var error20 = () => {
           return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
         }
         const adj = issue2.inclusive ? ">=" : ">";
-        const be = verbFor(issue2.origin ?? "value");
+        const be2 = verbFor(issue2.origin ?? "value");
         if (sizing?.unit) {
-          return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
+          return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be2} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
         }
-        return `${sizing?.shortLabel ?? "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()}`;
+        return `${sizing?.shortLabel ?? "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be2} ${adj}${issue2.minimum.toString()}`;
       }
       case "invalid_format": {
         const _issue = issue2;
@@ -14571,18 +14571,18 @@ ${code}` : code : "";
   const factoryCode = `return (input) => {
 ${code}
 }`;
-  let fn;
+  let fn2;
   try {
     const factory = new F(...constantNames, factoryCode);
-    fn = factory(...constantValues);
+    fn2 = factory(...constantValues);
   } catch (err) {
     throw new ZodCompileUnsupportedError(`this schema (generated code failed to evaluate: ${err.message})`);
   }
   if (options?.debug) {
-    fn.code = fullCode;
+    fn2.code = fullCode;
   }
-  fn.definite = ctx.definite;
-  return fn;
+  fn2.definite = ctx.definite;
+  return fn2;
 }
 function addConstant(ctx, value) {
   for (const [name2, v] of ctx.constants) {
@@ -14593,9 +14593,9 @@ function addConstant(ctx, value) {
   ctx.constants.set(name, value);
   return name;
 }
-function addUserConstant(ctx, fn) {
+function addUserConstant(ctx, fn2) {
   ctx.definite = false;
-  return addConstant(ctx, fn);
+  return addConstant(ctx, fn2);
 }
 function newVar(ctx) {
   return `v${ctx.varCounter++}`;
@@ -15989,8 +15989,8 @@ function generatePipeCheck(doc, ctx, schema, accessor) {
     return generateCheck(doc, ctx, def.out, inputOutput);
   }
 }
-function isAsyncFunction(fn) {
-  return typeof fn === "function" && (fn.constructor.name === "AsyncFunction" || fn[Symbol.toStringTag] === "AsyncFunction");
+function isAsyncFunction(fn2) {
+  return typeof fn2 === "function" && (fn2.constructor.name === "AsyncFunction" || fn2[Symbol.toStringTag] === "AsyncFunction");
 }
 function generateCustomCheck(doc, ctx, schema, accessor) {
   const def = schema._zod.def;
@@ -16883,10 +16883,10 @@ function _file(Class2, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _transform(Class2, fn) {
+function _transform(Class2, fn2) {
   return new Class2({
     type: "transform",
-    transform: fn
+    transform: fn2
   });
 }
 // @__NO_SIDE_EFFECTS__
@@ -16974,29 +16974,29 @@ function _promise(Class2, innerType) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _custom(Class2, fn, _params) {
+function _custom(Class2, fn2, _params) {
   const norm = normalizeParams(_params);
   norm.abort ?? (norm.abort = true);
   const schema = new Class2({
     type: "custom",
     check: "custom",
-    fn,
+    fn: fn2,
     ...norm
   });
   return schema;
 }
 // @__NO_SIDE_EFFECTS__
-function _refine(Class2, fn, _params) {
+function _refine(Class2, fn2, _params) {
   const schema = new Class2({
     type: "custom",
     check: "custom",
-    fn,
+    fn: fn2,
     ...normalizeParams(_params)
   });
   return schema;
 }
 // @__NO_SIDE_EFFECTS__
-function _superRefine(fn, params) {
+function _superRefine(fn2, params) {
   const ch = /* @__PURE__ */ _check((payload) => {
     payload.addIssue = (issue2) => {
       if (typeof issue2 === "string") {
@@ -17013,17 +17013,17 @@ function _superRefine(fn, params) {
         payload.issues.push(issue(_issue));
       }
     };
-    return fn(payload.value, payload);
+    return fn2(payload.value, payload);
   }, params);
   return ch;
 }
 // @__NO_SIDE_EFFECTS__
-function _check(fn, params) {
+function _check(fn2, params) {
   const ch = new $ZodCheck({
     check: "custom",
     ...normalizeParams(params)
   });
-  ch._zod.check = fn;
+  ch._zod.check = fn2;
   return ch;
 }
 // @__NO_SIDE_EFFECTS__
@@ -18802,8 +18802,8 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   superRefine(refinement, params) {
     return this.check(superRefine(refinement, params));
   },
-  overwrite(fn) {
-    return this.check(_overwrite(fn));
+  overwrite(fn2) {
+    return this.check(_overwrite(fn2));
   },
   optional() {
     return optional(this);
@@ -18865,8 +18865,8 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
   isNullable() {
     return this.safeParse(null).success;
   },
-  apply(fn, ...args) {
-    return args.length === 0 ? fn(this) : fn(this, ...args);
+  apply(fn2, ...args) {
+    return args.length === 0 ? fn2(this) : fn2(this, ...args);
   },
   // Overrides core's `~standard` to add `jsonSchema`. Must stay a prototype entry: redefining it per instance demotes instances to dictionary mode.
   get "~standard"() {
@@ -19926,10 +19926,10 @@ var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
     return payload;
   };
 });
-function transform(fn) {
+function transform(fn2) {
   return new ZodTransform({
     type: "transform",
-    transform: fn
+    transform: fn2
   });
 }
 var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
@@ -20156,22 +20156,22 @@ var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
   ZodType.init(inst, def);
   inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
 });
-function check(fn) {
+function check(fn2) {
   const ch = new $ZodCheck({
     check: "custom"
     // ...util.normalizeParams(params),
   });
-  ch._zod.check = fn;
+  ch._zod.check = fn2;
   return ch;
 }
-function custom(fn, _params) {
-  return _custom(ZodCustom, fn ?? (() => true), _params);
+function custom(fn2, _params) {
+  return _custom(ZodCustom, fn2 ?? (() => true), _params);
 }
-function refine(fn, _params = {}) {
-  return _refine(ZodCustom, fn, _params);
+function refine(fn2, _params = {}) {
+  return _refine(ZodCustom, fn2, _params);
 }
-function superRefine(fn, params) {
-  return _superRefine(fn, params);
+function superRefine(fn2, params) {
+  return _superRefine(fn2, params);
 }
 var describe2 = describe;
 var meta2 = meta;
@@ -20215,10 +20215,10 @@ function json(params) {
   });
   return jsonSchema;
 }
-function preprocess(fn, schema) {
+function preprocess(fn2, schema) {
   return new ZodPreprocess({
     type: "pipe",
-    in: transform(fn),
+    in: transform(fn2),
     out: schema
   });
 }
@@ -21010,7 +21010,7 @@ function fromJSONSchema(schema, params) {
 // node_modules/zod/v4/core/visit.js
 var RESOLVING = /* @__PURE__ */ Symbol("z.visit/resolving");
 function visit(schema, fnOrHandlers) {
-  const fn = typeof fnOrHandlers === "function" ? fnOrHandlers : (node2, rewritten) => {
+  const fn2 = typeof fnOrHandlers === "function" ? fnOrHandlers : (node2, rewritten) => {
     const h = fnOrHandlers[node2._zod.def.type];
     return h ? h(node2, rewritten) : node2;
   };
@@ -21027,7 +21027,7 @@ function visit(schema, fnOrHandlers) {
       return cached2;
     cache2.set(s, RESOLVING);
     const inner = mapInner(s);
-    const mapped = fn(inner, inner !== s);
+    const mapped = fn2(inner, inner !== s);
     cache2.set(s, mapped);
     return mapped;
   }
@@ -22286,8 +22286,8 @@ function parseExpression(tokens) {
     adv();
     const entries = [];
     while (cur().t !== 6 && cur().t !== 13) {
-      const kt = cur();
-      const key = kt.t === 16 || kt.t === 14 || kt.t === 17 || kt.t === 15 ? (adv(), String(kt.v)) : kt.t === 18 ? (adv(), kt.v.replace(/^\$/, "")) : (adv(), "?");
+      const kt2 = cur();
+      const key = kt2.t === 16 || kt2.t === 14 || kt2.t === 17 || kt2.t === 15 ? (adv(), String(kt2.v)) : kt2.t === 18 ? (adv(), kt2.v.replace(/^\$/, "")) : (adv(), "?");
       eat(8);
       entries.push([key, parseExpr(0)]);
       if (cur().t === 7) adv();
@@ -23182,8 +23182,8 @@ function split(tokens) {
     let depth = 0;
     let ternaryDepth = 0;
     while (pos < tokens.length && tokens[pos].t !== 13) {
-      const tt = tokens[pos].t;
-      if (tt === 0 && depth <= 0 && ternaryDepth <= 0) {
+      const tt2 = tokens[pos].t;
+      if (tt2 === 0 && depth <= 0 && ternaryDepth <= 0) {
         let peek = pos + 1;
         while (peek < tokens.length && tokens[peek].t === 0) peek++;
         const nextT = peek < tokens.length ? tokens[peek].t : 13;
@@ -23193,14 +23193,14 @@ function split(tokens) {
         }
         break;
       }
-      if (tt === 0) {
+      if (tt2 === 0) {
         pos++;
         continue;
       }
-      if (tt === 1 || tt === 3 || tt === 5) depth++;
-      else if ((tt === 2 || tt === 4 || tt === 6) && depth > 0) depth--;
-      else if (tt === 34 && depth === 0) ternaryDepth++;
-      else if (tt === 8 && depth === 0 && ternaryDepth > 0) ternaryDepth--;
+      if (tt2 === 1 || tt2 === 3 || tt2 === 5) depth++;
+      else if ((tt2 === 2 || tt2 === 4 || tt2 === 6) && depth > 0) depth--;
+      else if (tt2 === 34 && depth === 0) ternaryDepth++;
+      else if (tt2 === 8 && depth === 0 && ternaryDepth > 0) ternaryDepth--;
       expr.push(tokens[pos++]);
     }
     if (expr.length) stmts.push({
@@ -23547,9 +23547,9 @@ function compileSchema(schema) {
     map2.set(name, { params: compileParams(def, defs) });
   }
   map2.callDefs = new Map(BUILTIN_CALLS);
-  for (const [name, fn] of Object.entries(schema.functions ?? {})) map2.callDefs.set(name, {
+  for (const [name, fn2] of Object.entries(schema.functions ?? {})) map2.callDefs.set(name, {
     kind: "function",
-    params: compileParams(fn.params, defs)
+    params: compileParams(fn2.params, defs)
   });
   for (const [name, action] of Object.entries(schema.actions ?? {})) map2.callDefs.set(name, {
     kind: "action",
@@ -23755,6 +23755,3269 @@ function nextLineContinuesTernary(src, from) {
   return src[j] === "?" || src[j] === ":";
 }
 
+// node_modules/@dagrejs/dagre/dist/dagre.esm.js
+var Te = Object.defineProperty;
+var Sn = (e, n, t) => n in e ? Te(e, n, { enumerable: true, configurable: true, writable: true, value: t }) : e[n] = t;
+var Mn = (e, n) => {
+  for (var t in n) Te(e, t, { get: n[t], enumerable: true });
+};
+var je = (e, n, t) => Sn(e, typeof n != "symbol" ? n + "" : n, t);
+var ie = {};
+Mn(ie, { Graph: () => T, alg: () => H });
+var Pn = Object.defineProperty;
+var Se = (e, n) => {
+  for (var t in n) Pn(e, t, { get: n[t], enumerable: true });
+};
+var Q = class {
+  constructor(e) {
+    this._isDirected = true, this._isMultigraph = false, this._isCompound = false, this._nodes = {}, this._in = {}, this._preds = {}, this._out = {}, this._sucs = {}, this._edgeObjs = {}, this._edgeLabels = {}, this._nodeCount = 0, this._edgeCount = 0, this._defaultNodeLabelFn = () => {
+    }, this._defaultEdgeLabelFn = () => {
+    }, e && (this._isDirected = "directed" in e ? e.directed : true, this._isMultigraph = "multigraph" in e ? e.multigraph : false, this._isCompound = "compound" in e ? e.compound : false), this._isCompound && (this._parent = {}, this._children = {}, this._children["\0"] = {});
+  }
+  isDirected() {
+    return this._isDirected;
+  }
+  isMultigraph() {
+    return this._isMultigraph;
+  }
+  isCompound() {
+    return this._isCompound;
+  }
+  setGraph(e) {
+    return this._label = e, this;
+  }
+  graph() {
+    return this._label;
+  }
+  setDefaultNodeLabel(e) {
+    return typeof e != "function" ? this._defaultNodeLabelFn = () => e : this._defaultNodeLabelFn = e, this;
+  }
+  nodeCount() {
+    return this._nodeCount;
+  }
+  nodes() {
+    return Object.keys(this._nodes);
+  }
+  sources() {
+    return this.nodes().filter((e) => Object.keys(this._in[e]).length === 0);
+  }
+  sinks() {
+    return this.nodes().filter((e) => Object.keys(this._out[e]).length === 0);
+  }
+  setNodes(e, n) {
+    return e.forEach((t) => {
+      n !== void 0 ? this.setNode(t, n) : this.setNode(t);
+    }), this;
+  }
+  setNode(e, n) {
+    return e in this._nodes ? (arguments.length > 1 && (this._nodes[e] = n), this) : (this._nodes[e] = arguments.length > 1 ? n : this._defaultNodeLabelFn(e), this._isCompound && (this._parent[e] = "\0", this._children[e] = {}, this._children["\0"][e] = true), this._in[e] = {}, this._preds[e] = {}, this._out[e] = {}, this._sucs[e] = {}, ++this._nodeCount, this);
+  }
+  node(e) {
+    return this._nodes[e];
+  }
+  hasNode(e) {
+    return e in this._nodes;
+  }
+  removeNode(e) {
+    if (e in this._nodes) {
+      let n = (t) => this.removeEdge(this._edgeObjs[t]);
+      delete this._nodes[e], this._isCompound && (this._removeFromParentsChildList(e), delete this._parent[e], this.children(e).forEach((t) => {
+        this.setParent(t);
+      }), delete this._children[e]), Object.keys(this._in[e]).forEach(n), delete this._in[e], delete this._preds[e], Object.keys(this._out[e]).forEach(n), delete this._out[e], delete this._sucs[e], --this._nodeCount;
+    }
+    return this;
+  }
+  setParent(e, n) {
+    if (!this._isCompound) throw new Error("Cannot set parent in a non-compound graph");
+    if (n === void 0) n = "\0";
+    else {
+      n += "";
+      for (let t = n; t !== void 0; t = this.parent(t)) if (t === e) throw new Error("Setting " + n + " as parent of " + e + " would create a cycle");
+      this.setNode(n);
+    }
+    return this.setNode(e), this._removeFromParentsChildList(e), this._parent[e] = n, this._children[n][e] = true, this;
+  }
+  parent(e) {
+    if (this._isCompound) {
+      let n = this._parent[e];
+      if (n !== "\0") return n;
+    }
+  }
+  children(e = "\0") {
+    if (this._isCompound) {
+      let n = this._children[e];
+      if (n) return Object.keys(n);
+    } else {
+      if (e === "\0") return this.nodes();
+      if (this.hasNode(e)) return [];
+    }
+    return [];
+  }
+  predecessors(e) {
+    let n = this._preds[e];
+    if (n) return Object.keys(n);
+  }
+  successors(e) {
+    let n = this._sucs[e];
+    if (n) return Object.keys(n);
+  }
+  neighbors(e) {
+    let n = this.predecessors(e);
+    if (n) {
+      let t = new Set(n), r = this.successors(e);
+      if (r) for (let o of r) t.add(o);
+      return Array.from(t.values());
+    }
+  }
+  isLeaf(e) {
+    var n;
+    let t;
+    return this.isDirected() ? t = this.successors(e) : t = this.neighbors(e), ((n = t == null ? void 0 : t.length) != null ? n : 0) === 0;
+  }
+  filterNodes(e) {
+    let n = new this.constructor({ directed: this._isDirected, multigraph: this._isMultigraph, compound: this._isCompound });
+    n.setGraph(this.graph()), Object.entries(this._nodes).forEach(([o, i]) => {
+      e(o) && n.setNode(o, i);
+    }), Object.values(this._edgeObjs).forEach((o) => {
+      n.hasNode(o.v) && n.hasNode(o.w) && n.setEdge(o, this.edge(o));
+    });
+    let t = {}, r = (o) => {
+      let i = this.parent(o);
+      return !i || n.hasNode(i) ? (t[o] = i, i) : i in t ? t[i] : r(i);
+    };
+    return this._isCompound && n.nodes().forEach((o) => n.setParent(o, r(o))), n;
+  }
+  setDefaultEdgeLabel(e) {
+    return typeof e != "function" ? this._defaultEdgeLabelFn = () => e : this._defaultEdgeLabelFn = e, this;
+  }
+  edgeCount() {
+    return this._edgeCount;
+  }
+  edges() {
+    return Object.values(this._edgeObjs);
+  }
+  setPath(e, n) {
+    return e.reduce((t, r) => (n !== void 0 ? this.setEdge(t, r, n) : this.setEdge(t, r), r)), this;
+  }
+  setEdge(e, n, t, r) {
+    let o, i, s, a, l = false;
+    typeof e == "object" && e !== null && "v" in e ? (o = e.v, i = e.w, s = e.name, arguments.length === 2 && (a = n, l = true)) : (o = e, i = n, s = r, arguments.length > 2 && (a = t, l = true)), o = "" + o, i = "" + i, s !== void 0 && (s = "" + s);
+    let u = z2(this._isDirected, o, i, s);
+    if (u in this._edgeLabels) return l && (this._edgeLabels[u] = a), this;
+    if (s !== void 0 && !this._isMultigraph) throw new Error("Cannot set a named edge when isMultigraph = false");
+    this.setNode(o), this.setNode(i), this._edgeLabels[u] = l ? a : this._defaultEdgeLabelFn(o, i, s);
+    let d = Fn(this._isDirected, o, i, s);
+    return o = d.v, i = d.w, Object.freeze(d), this._edgeObjs[u] = d, Re(this._preds[i], o), Re(this._sucs[o], i), this._in[i][u] = d, this._out[o][u] = d, this._edgeCount++, this;
+  }
+  edge(e, n, t) {
+    let r = arguments.length === 1 ? oe(this._isDirected, e) : z2(this._isDirected, e, n, t);
+    return this._edgeLabels[r];
+  }
+  edgeAsObj(e, n, t) {
+    let r = arguments.length === 1 ? this.edge(e) : this.edge(e, n, t);
+    return typeof r != "object" || r === null ? { label: r } : r;
+  }
+  hasEdge(e, n, t) {
+    return (arguments.length === 1 ? oe(this._isDirected, e) : z2(this._isDirected, e, n, t)) in this._edgeLabels;
+  }
+  removeEdge(e, n, t) {
+    let r = arguments.length === 1 ? oe(this._isDirected, e) : z2(this._isDirected, e, n, t), o = this._edgeObjs[r];
+    if (o) {
+      let i = o.v, s = o.w;
+      delete this._edgeLabels[r], delete this._edgeObjs[r], Ie(this._preds[s], i), Ie(this._sucs[i], s), delete this._in[s][r], delete this._out[i][r], this._edgeCount--;
+    }
+    return this;
+  }
+  inEdges(e, n) {
+    return this.isDirected() ? this.filterEdges(this._in[e], e, n) : this.nodeEdges(e, n);
+  }
+  outEdges(e, n) {
+    return this.isDirected() ? this.filterEdges(this._out[e], e, n) : this.nodeEdges(e, n);
+  }
+  nodeEdges(e, n) {
+    if (e in this._nodes) return this.filterEdges({ ...this._in[e], ...this._out[e] }, e, n);
+  }
+  _removeFromParentsChildList(e) {
+    delete this._children[this._parent[e]][e];
+  }
+  filterEdges(e, n, t) {
+    if (!e) return;
+    let r = Object.values(e);
+    return t ? r.filter((o) => o.v === n && o.w === t || o.v === t && o.w === n) : r;
+  }
+};
+function Re(e, n) {
+  e[n] ? e[n]++ : e[n] = 1;
+}
+function Ie(e, n) {
+  e[n] !== void 0 && !--e[n] && delete e[n];
+}
+function z2(e, n, t, r) {
+  let o = "" + n, i = "" + t;
+  if (!e && o > i) {
+    let s = o;
+    o = i, i = s;
+  }
+  return o + "
" + i + "
" + (r === void 0 ? "\0" : r);
+}
+function Fn(e, n, t, r) {
+  let o = "" + n, i = "" + t;
+  if (!e && o > i) {
+    let a = o;
+    o = i, i = a;
+  }
+  let s = { v: o, w: i };
+  return r && (s.name = r), s;
+}
+function oe(e, n) {
+  return z2(e, n.v, n.w, n.name);
+}
+var Dn = {};
+Se(Dn, { read: () => Bn, write: () => An });
+function An(e) {
+  let n = { options: { directed: e.isDirected(), multigraph: e.isMultigraph(), compound: e.isCompound() }, nodes: Vn(e), edges: Yn(e) }, t = e.graph();
+  return t !== void 0 && (n.value = structuredClone(t)), n;
+}
+function Vn(e) {
+  return e.nodes().map((n) => {
+    let t = e.node(n), r = e.parent(n), o = { v: n };
+    return t !== void 0 && (o.value = t), r !== void 0 && (o.parent = r), o;
+  });
+}
+function Yn(e) {
+  return e.edges().map((n) => {
+    let t = e.edge(n), r = { v: n.v, w: n.w };
+    return n.name !== void 0 && (r.name = n.name), t !== void 0 && (r.value = t), r;
+  });
+}
+function Bn(e) {
+  let n = new Q(e.options);
+  return e.value !== void 0 && n.setGraph(e.value), e.nodes.forEach((t) => {
+    n.setNode(t.v, t.value), t.parent && n.setParent(t.v, t.parent);
+  }), e.edges.forEach((t) => {
+    n.setEdge({ v: t.v, w: t.w, name: t.name }, t.value);
+  }), n;
+}
+var H = {};
+Se(H, { CycleException: () => K, bellmanFord: () => Me, components: () => zn, dijkstra: () => J, dijkstraAll: () => $n, findCycles: () => Un, floydWarshall: () => Kn, isAcyclic: () => Zn, postorder: () => nt, preorder: () => tt, prim: () => rt, shortestPaths: () => ot, tarjan: () => Fe, topsort: () => De });
+var Wn = () => 1;
+function Me(e, n, t, r) {
+  return Xn(e, String(n), t || Wn, r || function(o) {
+    var i;
+    return (i = e.outEdges(o)) != null ? i : [];
+  });
+}
+function Xn(e, n, t, r) {
+  let o = {}, i, s = 0, a = e.nodes(), l = function(c) {
+    let f = o[c.v], h = o[c.w];
+    if (!f || !h) return;
+    let g = t(c);
+    f.distance + g < h.distance && (o[c.w] = { distance: f.distance + g, predecessor: c.v }, i = true);
+  }, u = function() {
+    a.forEach(function(c) {
+      r(c).forEach(function(f) {
+        let h = f.v === c ? f.v : f.w, g = h === f.v ? f.w : f.v;
+        l({ v: h, w: g });
+      });
+    });
+  };
+  a.forEach(function(c) {
+    let f = c === n ? 0 : Number.POSITIVE_INFINITY;
+    o[c] = { distance: f, predecessor: "" };
+  });
+  let d = a.length;
+  for (let c = 1; c < d && (i = false, s++, u(), !!i); c++) ;
+  if (s === d - 1 && (i = false, u(), i)) throw new Error("The graph contains a negative weight cycle");
+  return o;
+}
+function zn(e) {
+  let n = {}, t = [], r;
+  function o(i) {
+    var s, a;
+    i in n || (n[i] = true, r.push(i), (s = e.successors(i)) == null || s.forEach(o), (a = e.predecessors(i)) == null || a.forEach(o));
+  }
+  return e.nodes().forEach(function(i) {
+    r = [], o(i), r.length && t.push(r);
+  }), t;
+}
+var Pe = class {
+  constructor() {
+    this._arr = [], this._keyIndices = {};
+  }
+  size() {
+    return this._arr.length;
+  }
+  keys() {
+    return this._arr.map((e) => e.key);
+  }
+  has(e) {
+    return e in this._keyIndices;
+  }
+  priority(e) {
+    let n = this._keyIndices[e];
+    if (n !== void 0) return this._arr[n].priority;
+  }
+  min() {
+    if (this.size() === 0) throw new Error("Queue underflow");
+    return this._arr[0].key;
+  }
+  add(e, n) {
+    let t = this._keyIndices, r = String(e);
+    if (!(r in t)) {
+      let o = this._arr, i = o.length;
+      return t[r] = i, o.push({ key: r, priority: n }), this._decrease(i), true;
+    }
+    return false;
+  }
+  removeMin() {
+    if (this.size() === 0) throw new Error("Queue underflow");
+    this._swap(0, this._arr.length - 1);
+    let e = this._arr.pop();
+    return delete this._keyIndices[e.key], this._heapify(0), e.key;
+  }
+  decrease(e, n) {
+    let t = this._keyIndices[e];
+    if (t === void 0) throw new Error(`Key not found: ${e}`);
+    let r = this._arr[t].priority;
+    if (n > r) throw new Error(`New priority is greater than current priority. Key: ${e} Old: ${r} New: ${n}`);
+    this._arr[t].priority = n, this._decrease(t);
+  }
+  _heapify(e) {
+    let n = this._arr, t = 2 * e, r = t + 1, o = e;
+    t < n.length && (o = n[t].priority < n[o].priority ? t : o, r < n.length && (o = n[r].priority < n[o].priority ? r : o), o !== e && (this._swap(e, o), this._heapify(o)));
+  }
+  _decrease(e) {
+    let n = this._arr, t = n[e].priority, r;
+    for (; e !== 0 && (r = e >> 1, !(n[r].priority < t)); ) this._swap(e, r), e = r;
+  }
+  _swap(e, n) {
+    let t = this._arr, r = this._keyIndices, o = t[e], i = t[n];
+    t[e] = i, t[n] = o, r[i.key] = e, r[o.key] = n;
+  }
+};
+var Hn = () => 1;
+function J(e, n, t, r) {
+  let o = function(i) {
+    var s;
+    return (s = e.outEdges(i)) != null ? s : [];
+  };
+  return qn(e, String(n), t || Hn, r || o);
+}
+function qn(e, n, t, r) {
+  let o = {}, i = new Pe(), s, a, l = function(u) {
+    let d = u.v !== s ? u.v : u.w, c = o[d];
+    if (!c) return;
+    let f = t(u), h = a.distance + f;
+    if (f < 0) throw new Error("dijkstra does not allow negative edge weights. Bad edge: " + u + " Weight: " + f);
+    h < c.distance && (c.distance = h, c.predecessor = s, i.decrease(d, h));
+  };
+  for (e.nodes().forEach(function(u) {
+    let d = u === n ? 0 : Number.POSITIVE_INFINITY;
+    o[u] = { distance: d, predecessor: "" }, i.add(u, d);
+  }); i.size() > 0; ) {
+    s = i.removeMin();
+    let u = o[s];
+    if (!u || u.distance === Number.POSITIVE_INFINITY) break;
+    a = u, r(s).forEach(l);
+  }
+  return o;
+}
+function $n(e, n, t) {
+  return e.nodes().reduce(function(r, o) {
+    return r[o] = J(e, o, n, t), r;
+  }, {});
+}
+function Fe(e) {
+  let n = 0, t = [], r = {}, o = [];
+  function i(s) {
+    var a;
+    let l = r[s] = { onStack: true, lowlink: n, index: n++ };
+    if (t.push(s), (a = e.successors(s)) == null || a.forEach(function(u) {
+      if (u in r) {
+        let d = r[u];
+        d != null && d.onStack && (l.lowlink = Math.min(l.lowlink, d.index));
+      } else {
+        i(u);
+        let d = r[u];
+        d && (l.lowlink = Math.min(l.lowlink, d.lowlink));
+      }
+    }), l.lowlink === l.index) {
+      let u = [], d;
+      do {
+        d = t.pop();
+        let c = r[d];
+        c && (c.onStack = false), u.push(d);
+      } while (s !== d);
+      o.push(u);
+    }
+  }
+  return e.nodes().forEach(function(s) {
+    s in r || i(s);
+  }), o;
+}
+function Un(e) {
+  return Fe(e).filter(function(n) {
+    var t;
+    let r = n[0];
+    return r ? n.length > 1 || n.length === 1 && ((t = e.outEdges(r, r)) != null ? t : []).length > 0 : false;
+  });
+}
+var Jn = () => 1;
+function Kn(e, n, t) {
+  return Qn(e, n || Jn, t || function(r) {
+    var o;
+    return (o = e.outEdges(r)) != null ? o : [];
+  });
+}
+function Qn(e, n, t) {
+  let r = {}, o = e.nodes();
+  return o.forEach(function(i) {
+    let s = {};
+    r[i] = s, s[i] = { distance: 0, predecessor: "" }, o.forEach(function(a) {
+      i !== a && (s[a] = { distance: Number.POSITIVE_INFINITY, predecessor: "" });
+    }), t(i).forEach(function(a) {
+      let l = a.v === i ? a.w : a.v, u = n(a);
+      s[l] = { distance: u, predecessor: i };
+    });
+  }), o.forEach(function(i) {
+    let s = r[i];
+    s && o.forEach(function(a) {
+      let l = r[a];
+      l && o.forEach(function(u) {
+        let d = l[i], c = s[u], f = l[u];
+        if (d && c && f) {
+          let h = d.distance + c.distance;
+          h < f.distance && (f.distance = h, f.predecessor = c.predecessor);
+        }
+      });
+    });
+  }), r;
+}
+var K = class extends Error {
+  constructor(e) {
+    super(e), this.name = "CycleException";
+  }
+};
+function De(e) {
+  let n = {}, t = {}, r = [];
+  function o(i) {
+    var s;
+    if (i in t) throw new K();
+    i in n || (t[i] = true, n[i] = true, (s = e.predecessors(i)) == null || s.forEach(o), delete t[i], r.push(i));
+  }
+  if (e.sinks().forEach(o), Object.keys(n).length !== e.nodeCount()) throw new K();
+  return r;
+}
+function Zn(e) {
+  try {
+    De(e);
+  } catch (n) {
+    if (n instanceof K) return false;
+    throw n;
+  }
+  return true;
+}
+function et(e, n, t, r, o) {
+  Array.isArray(n) || (n = [n]);
+  let i = ((a) => {
+    var l;
+    return (l = e.isDirected() ? e.successors(a) : e.neighbors(a)) != null ? l : [];
+  }), s = {};
+  return n.forEach(function(a) {
+    if (!e.hasNode(a)) throw new Error("Graph does not have node: " + a);
+    o = Ae(e, a, t === "post", s, i, r, o);
+  }), o;
+}
+function Ae(e, n, t, r, o, i, s) {
+  return n in r || (r[n] = true, t || (s = i(s, n)), o(n).forEach(function(a) {
+    s = Ae(e, a, t, r, o, i, s);
+  }), t && (s = i(s, n))), s;
+}
+function Ve(e, n, t) {
+  return et(e, n, t, function(r, o) {
+    return r.push(o), r;
+  }, []);
+}
+function nt(e, n) {
+  return Ve(e, n, "post");
+}
+function tt(e, n) {
+  return Ve(e, n, "pre");
+}
+function rt(e, n) {
+  var t;
+  let r = new Q(), o = {}, i = new Pe(), s;
+  function a(d) {
+    let c = d.v === s ? d.w : d.v, f = i.priority(c);
+    if (f !== void 0) {
+      let h = n(d);
+      h < f && (o[c] = s, i.decrease(c, h));
+    }
+  }
+  if (e.nodeCount() === 0) return r;
+  e.nodes().forEach(function(d) {
+    i.add(d, Number.POSITIVE_INFINITY), r.setNode(d);
+  });
+  let l = e.nodes()[0];
+  l !== void 0 && i.decrease(l, 0);
+  let u = false;
+  for (; i.size() > 0; ) {
+    if (s = i.removeMin(), s in o) r.setEdge(s, o[s]);
+    else {
+      if (u) throw new Error("Input graph is not connected: " + e);
+      u = true;
+    }
+    (t = e.nodeEdges(s)) == null || t.forEach(a);
+  }
+  return r;
+}
+function ot(e, n, t, r) {
+  return it(e, n, t, r != null ? r : ((o) => {
+    var i;
+    return (i = e.outEdges(o)) != null ? i : [];
+  }));
+}
+function it(e, n, t, r) {
+  if (t === void 0) return J(e, n, t, r);
+  let o = false, i = e.nodes();
+  for (let s = 0; s < i.length; s++) {
+    let a = i[s];
+    if (a === void 0) continue;
+    let l = r(a);
+    for (let u = 0; u < l.length; u++) {
+      let d = l[u];
+      if (!d) continue;
+      let c = d.v === a ? d.v : d.w, f = c === d.v ? d.w : d.v;
+      t({ v: c, w: f }) < 0 && (o = true);
+    }
+    if (o) return Me(e, n, t, r);
+  }
+  return J(e, n, t, r);
+}
+var T = Q;
+function M(e, n, t, r) {
+  let o = r;
+  for (; e.hasNode(o); ) o = $(r);
+  return t.dummy = n, e.setNode(o, t), o;
+}
+function Ye(e) {
+  let n = new T().setGraph(e.graph());
+  return e.nodes().forEach((t) => n.setNode(t, e.node(t))), e.edges().forEach((t) => {
+    let r = n.edge(t.v, t.w) || { weight: 0, minlen: 1 }, o = e.edge(t);
+    n.setEdge(t.v, t.w, { weight: r.weight + o.weight, minlen: Math.max(r.minlen, o.minlen) });
+  }), n;
+}
+function Z(e) {
+  let n = new T({ multigraph: e.isMultigraph() }).setGraph(e.graph());
+  return e.nodes().forEach((t) => {
+    e.children(t).length || n.setNode(t, e.node(t));
+  }), e.edges().forEach((t) => {
+    n.setEdge(t, e.edge(t));
+  }), n;
+}
+function se(e, n) {
+  let t = e.x, r = e.y, o = n.x - t, i = n.y - r, s = e.width / 2, a = e.height / 2;
+  if (!o && !i) throw new Error("Not possible to find intersection inside of the rectangle");
+  let l, u;
+  return o === 0 || Math.abs(i) * s > Math.abs(o) * a ? (i < 0 && (a = -a), l = a * o / i, u = a) : (o < 0 && (s = -s), l = s, u = s * i / o), { x: t + l, y: r + u };
+}
+function P(e) {
+  let n = D(de(e) + 1).map(() => []);
+  return e.nodes().forEach((t) => {
+    let r = e.node(t), o = r.rank;
+    o !== void 0 && (n[o] || (n[o] = []), n[o][r.order] = t);
+  }), n;
+}
+function Be(e) {
+  let n = e.nodes().map((r) => {
+    let o = e.node(r).rank;
+    return o === void 0 ? Number.MAX_VALUE : o;
+  }), t = S(Math.min, n);
+  e.nodes().forEach((r) => {
+    let o = e.node(r);
+    Object.hasOwn(o, "rank") && (o.rank -= t);
+  });
+}
+function We(e) {
+  let n = e.nodes().map((s) => e.node(s).rank).filter((s) => s !== void 0), t = S(Math.min, n), r = [];
+  e.nodes().forEach((s) => {
+    let a = e.node(s).rank - t;
+    r[a] || (r[a] = []), r[a].push(s);
+  });
+  let o = 0, i = e.graph().nodeRankFactor;
+  Array.from(r).forEach((s, a) => {
+    s === void 0 && a % i !== 0 ? --o : s !== void 0 && o && s.forEach((l) => e.node(l).rank += o);
+  });
+}
+function ae(e, n, t, r) {
+  let o = { width: 0, height: 0 };
+  return arguments.length >= 4 && (o.rank = t, o.order = r), M(e, "border", o, n);
+}
+function st(e, n = Xe) {
+  let t = [];
+  for (let r = 0; r < e.length; r += n) {
+    let o = e.slice(r, r + n);
+    t.push(o);
+  }
+  return t;
+}
+var Xe = 65535;
+function S(e, n) {
+  if (n.length > Xe) {
+    let t = st(n);
+    return e(...t.map((r) => e(...r)));
+  } else return e(...n);
+}
+function de(e) {
+  let t = e.nodes().map((r) => {
+    let o = e.node(r).rank;
+    return o === void 0 ? Number.MIN_VALUE : o;
+  });
+  return S(Math.max, t);
+}
+function ze(e, n) {
+  let t = { lhs: [], rhs: [] };
+  return e.forEach((r) => {
+    n(r) ? t.lhs.push(r) : t.rhs.push(r);
+  }), t;
+}
+function le(e, n) {
+  let t = Date.now();
+  try {
+    return n();
+  } finally {
+    console.log(e + " time: " + (Date.now() - t) + "ms");
+  }
+}
+function q(e, n) {
+  return n();
+}
+var at = 0;
+function $(e) {
+  let n = ++at;
+  return e + ("" + n);
+}
+function D(e, n, t = 1) {
+  n == null && (n = e, e = 0);
+  let r = (i) => i < n;
+  t < 0 && (r = (i) => n < i);
+  let o = [];
+  for (let i = e; r(i); i += t) o.push(i);
+  return o;
+}
+function W(e, n) {
+  let t = {};
+  for (let r of n) e[r] !== void 0 && (t[r] = e[r]);
+  return t;
+}
+function X(e, n) {
+  let t;
+  return typeof n == "string" ? t = (r) => r[n] : t = n, Object.entries(e).reduce((r, [o, i]) => (r[o] = t(i, o), r), {});
+}
+function He(e, n) {
+  return e.reduce((t, r, o) => (t[r] = n[o], t), {});
+}
+var V = "\0";
+function ee(e, n, t) {
+  var u, d, c, f, h, g;
+  if (!(e && n && t && n.dummy === "edge" && t.dummy === "edge" && n.edgeObj && t.edgeObj && e[n.edgeObj.v] && e[t.edgeObj.v] && e[n.edgeObj.w] && e[t.edgeObj.w])) return 0;
+  let r = true;
+  n.edgeObj.w === t.edgeObj.w && (r = false);
+  let o = r ? (d = (u = e[n.edgeObj.v]) == null ? void 0 : u.rank) != null ? d : NaN + 1 : (f = (c = e[n.edgeObj.w]) == null ? void 0 : c.rank) != null ? f : NaN - 1, i = Object.entries(e).find((m) => {
+    var L, y;
+    return ((L = m[1].edgeObj) == null ? void 0 : L.v) === n.edgeObj.v && ((y = m[1].edgeObj) == null ? void 0 : y.w) === n.edgeObj.w && m[1].rank === o;
+  }), s = Object.entries(e).find((m) => {
+    var L, y;
+    return ((L = m[1].edgeObj) == null ? void 0 : L.v) === t.edgeObj.v && ((y = m[1].edgeObj) == null ? void 0 : y.w) === t.edgeObj.w && m[1].rank === o;
+  });
+  if (!i || !s) return 0;
+  let a = (h = i[1].order) != null ? h : NaN, l = (g = s[1].order) != null ? g : NaN;
+  return isNaN(a - l) ? 0 : a - l;
+}
+var ue = "3.1.3";
+var ce = class {
+  constructor() {
+    je(this, "_sentinel");
+    let n = {};
+    n._next = n._prev = n, this._sentinel = n;
+  }
+  dequeue() {
+    let n = this._sentinel, t = n._prev;
+    if (t !== n) return qe(t), t;
+  }
+  enqueue(n) {
+    let t = this._sentinel;
+    n._prev && n._next && qe(n), n._next = t._next, t._next._prev = n, t._next = n, n._prev = t;
+  }
+  toString() {
+    let n = [], t = this._sentinel, r = t._prev;
+    for (; r !== t; ) n.push(JSON.stringify(r, dt)), r = r._prev;
+    return "[" + n.join(", ") + "]";
+  }
+};
+function qe(e) {
+  e._prev._next = e._next, e._next._prev = e._prev, delete e._next, delete e._prev;
+}
+function dt(e, n) {
+  if (e !== "_next" && e !== "_prev") return n;
+}
+var $e = ce;
+var lt = () => 1;
+function be(e, n) {
+  if (e.nodeCount() <= 1) return [];
+  let t = ct(e, n || lt);
+  return ut(t.graph, t.buckets, t.zeroIdx).flatMap((o) => e.outEdges(o.v, o.w) || []);
+}
+function ut(e, n, t) {
+  var a;
+  let r = [], o = n[n.length - 1], i = n[0], s;
+  for (; e.nodeCount(); ) {
+    for (; s = i.dequeue(); ) fe(e, n, t, s);
+    for (; s = o.dequeue(); ) fe(e, n, t, s);
+    if (e.nodeCount()) {
+      for (let l = n.length - 2; l > 0; --l) if (s = (a = n[l]) == null ? void 0 : a.dequeue(), s) {
+        r = r.concat(fe(e, n, t, s, true) || []);
+        break;
+      }
+    }
+  }
+  return r;
+}
+function fe(e, n, t, r, o) {
+  let i = [], s = o ? i : void 0;
+  return (e.inEdges(r.v) || []).forEach((a) => {
+    let l = e.edge(a), u = e.node(a.v);
+    o && i.push({ v: a.v, w: a.w }), u.out -= l, he(n, t, u);
+  }), (e.outEdges(r.v) || []).forEach((a) => {
+    let l = e.edge(a), u = a.w, d = e.node(u);
+    d.in -= l, he(n, t, d);
+  }), e.removeNode(r.v), s;
+}
+function ct(e, n) {
+  let t = new T(), r = 0, o = 0;
+  e.nodes().forEach((a) => {
+    t.setNode(a, { v: a, in: 0, out: 0 });
+  }), e.edges().forEach((a) => {
+    let l = t.edge(a.v, a.w) || 0, u = n(a), d = l + u;
+    t.setEdge(a.v, a.w, d);
+    let c = t.node(a.v), f = t.node(a.w);
+    o = Math.max(o, c.out += u), r = Math.max(r, f.in += u);
+  });
+  let i = ft(o + r + 3).map(() => new $e()), s = r + 1;
+  return t.nodes().forEach((a) => {
+    he(i, s, t.node(a));
+  }), { graph: t, buckets: i, zeroIdx: s };
+}
+function he(e, n, t) {
+  var r, o, i;
+  t.out ? t.in ? (i = e[t.out - t.in + n]) == null || i.enqueue(t) : (o = e[e.length - 1]) == null || o.enqueue(t) : (r = e[0]) == null || r.enqueue(t);
+}
+function ft(e) {
+  let n = [];
+  for (let t = 0; t < e; t++) n.push(t);
+  return n;
+}
+function Ue(e, n) {
+  (e.graph().acyclicer === "greedy" ? be(e, r(e)) : ht(e, n != null ? n : null)).forEach((o) => {
+    let i = e.edge(o);
+    e.removeEdge(o), i.forwardName = o.name, i.reversed = true, e.setEdge(o.w, o.v, i, $("rev"));
+  });
+  function r(o) {
+    return (i) => o.edge(i).weight;
+  }
+}
+function ht(e, n) {
+  let t = [], r = {}, o = {};
+  function i(l) {
+    Object.hasOwn(o, l) || (o[l] = true, r[l] = true, e.outEdges(l).forEach((u) => {
+      Object.hasOwn(r, u.w) ? t.push(u) : i(u.w);
+    }), delete r[l]);
+  }
+  function s(l) {
+    var u;
+    Object.hasOwn(o, l) || (o[l] = true, r[l] = true, (u = e.outEdges(l)) == null || u.forEach((d) => {
+      var c, f;
+      Object.hasOwn(r, d.w) || ((c = n.node(l)) == null ? void 0 : c.rank) > ((f = n.node(d.w)) == null ? void 0 : f.rank) && bt(e, d.w, d) ? t.push(d) : s(d.w);
+    }), delete r[l]);
+  }
+  let a = i;
+  return n && typeof n.node == "function" && (a = s), e.sources().forEach(a), e.nodes().forEach(a), t;
+}
+function Je(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n);
+    if (t.reversed) {
+      e.removeEdge(n);
+      let r = t.forwardName;
+      delete t.reversed, delete t.forwardName, e.setEdge(n.w, n.v, t, r);
+    }
+  });
+}
+function bt(e, n, t) {
+  let r = /* @__PURE__ */ new Set();
+  function o(i) {
+    var s;
+    if (e.sources().includes(i)) return true;
+    r.add(i);
+    for (let a of (s = e.inEdges(i)) != null ? s : []) if (!(a.v === t.v && a.w === t.w) && !r.has(a.v) && o(a.v)) return true;
+    return false;
+  }
+  return o(n);
+}
+function Ke(e) {
+  e.graph().dummyChains = [], e.edges().forEach((n) => pt(e, n));
+}
+function pt(e, n) {
+  let t = n.v, r = e.node(t).rank, o = n.w, i = e.node(o).rank, s = n.name, a = e.edge(n), l = a.labelRank;
+  if (i === r + 1) return;
+  e.removeEdge(n);
+  let u, d, c;
+  for (c = 0, ++r; r < i; ++c, ++r) a.points = [], d = { width: 0, height: 0, edgeLabel: a, edgeObj: n, rank: r }, u = M(e, "edge", d, "_d"), r === l && (d.width = a.width, d.height = a.height, d.dummy = "edge-label", d.labelpos = a.labelpos), e.setEdge(t, u, { weight: a.weight }, s), c === 0 && e.graph().dummyChains.push(u), t = u;
+  e.setEdge(t, o, { weight: a.weight }, s);
+}
+function Qe(e) {
+  e.graph().dummyChains.forEach((n) => {
+    let t = e.node(n), r = t.edgeLabel, o;
+    for (e.setEdge(t.edgeObj, r); t.dummy; ) o = e.successors(n)[0], e.removeNode(n), r.points.push({ x: t.x, y: t.y }), t.dummy === "edge-label" && (r.x = t.x, r.y = t.y, r.width = t.width, r.height = t.height), n = o, t = e.node(n);
+  });
+}
+function U(e) {
+  let n = {};
+  function t(r) {
+    let o = e.node(r);
+    if (Object.hasOwn(n, r)) return o.rank;
+    n[r] = true;
+    let i = e.outEdges(r), s = i ? i.map((l) => l == null ? Number.POSITIVE_INFINITY : t(l.w) - e.edge(l).minlen) : [], a = S(Math.min, s);
+    return a === Number.POSITIVE_INFINITY && (a = 0), o.rank = a;
+  }
+  e.sources().forEach(t);
+}
+function A(e, n) {
+  return e.node(n.w).rank - e.node(n.v).rank - e.edge(n).minlen;
+}
+var ne = Et;
+function Et(e) {
+  let n = new T({ directed: false }), t = e.nodes();
+  if (t.length === 0) throw new Error("Graph must have at least one node");
+  let r = t[0], o = e.nodeCount();
+  n.setNode(r, {});
+  let i, s;
+  for (; Lt(n, e) < o && (i = yt(n, e), !!i); ) s = n.hasNode(i.v) ? A(e, i) : -A(e, i), wt(n, e, s);
+  return n;
+}
+function Lt(e, n) {
+  function t(r) {
+    let o = n.nodeEdges(r);
+    o && o.forEach((i) => {
+      let s = i.v, a = r === s ? i.w : s;
+      !e.hasNode(a) && !A(n, i) && (e.setNode(a, {}), e.setEdge(r, a, {}), t(a));
+    });
+  }
+  return e.nodes().forEach(t), e.nodeCount();
+}
+function yt(e, n) {
+  return n.edges().reduce((r, o) => {
+    let i = Number.POSITIVE_INFINITY;
+    return e.hasNode(o.v) !== e.hasNode(o.w) && (i = A(n, o)), i < r[0] ? [i, o] : r;
+  }, [Number.POSITIVE_INFINITY, null])[1];
+}
+function wt(e, n, t) {
+  e.nodes().forEach((r) => n.node(r).rank += t);
+}
+var { preorder: Nt, postorder: Gt } = H;
+var en = Y;
+Y.initLowLimValues = pe;
+Y.initCutValues = ge;
+Y.calcCutValue = nn;
+Y.leaveEdge = rn;
+Y.enterEdge = on;
+Y.exchangeEdges = sn;
+function Y(e) {
+  e = Ye(e), U(e);
+  let n = ne(e);
+  pe(n), ge(n, e);
+  let t, r;
+  for (; t = rn(n); ) r = on(n, e, t), sn(n, e, t, r);
+}
+function ge(e, n) {
+  let t = Gt(e, e.nodes());
+  t = t.slice(0, t.length - 1), t.forEach((r) => vt(e, n, r));
+}
+function vt(e, n, t) {
+  let o = e.node(t).parent, i = e.edge(t, o);
+  i.cutvalue = nn(e, n, t);
+}
+function nn(e, n, t) {
+  let o = e.node(t).parent, i = true, s = n.edge(t, o), a = 0;
+  s || (i = false, s = n.edge(o, t)), a = s.weight;
+  let l = n.nodeEdges(t);
+  return l && l.forEach((u) => {
+    let d = u.v === t, c = d ? u.w : u.v;
+    if (c !== o) {
+      let f = d === i, h = n.edge(u).weight;
+      if (a += f ? h : -h, xt(e, t, c)) {
+        let m = e.edge(t, c).cutvalue;
+        a += f ? -m : m;
+      }
+    }
+  }), a;
+}
+function pe(e, n) {
+  arguments.length < 2 && (n = e.nodes()[0]), tn(e, {}, 1, n);
+}
+function tn(e, n, t, r, o) {
+  let i = t, s = e.node(r);
+  n[r] = true;
+  let a = e.neighbors(r);
+  return a && a.forEach((l) => {
+    Object.hasOwn(n, l) || (t = tn(e, n, t, l, r));
+  }), s.low = i, s.lim = t++, o ? s.parent = o : delete s.parent, t;
+}
+function rn(e) {
+  return e.edges().find((n) => e.edge(n).cutvalue < 0);
+}
+function on(e, n, t) {
+  let r = t.v, o = t.w;
+  n.hasEdge(r, o) || (r = t.w, o = t.v);
+  let i = e.node(r), s = e.node(o), a = i, l = false;
+  return i.lim > s.lim && (a = s, l = true), n.edges().filter((d) => l === Ze(e, e.node(d.v), a) && l !== Ze(e, e.node(d.w), a)).reduce((d, c) => A(n, c) < A(n, d) ? c : d);
+}
+function sn(e, n, t, r) {
+  let o = t.v, i = t.w;
+  e.removeEdge(o, i), e.setEdge(r.v, r.w, {}), pe(e), ge(e, n), kt(e, n);
+}
+function kt(e, n) {
+  let t = e.nodes().find((o) => !e.node(o).parent);
+  if (!t) return;
+  let r = Nt(e, [t]);
+  r = r.slice(1), r.forEach((o) => {
+    let s = e.node(o).parent, a = n.edge(o, s), l = false;
+    a || (a = n.edge(s, o), l = true), n.node(o).rank = n.node(s).rank + (l ? a.minlen : -a.minlen);
+  });
+}
+function xt(e, n, t) {
+  return e.hasEdge(n, t);
+}
+function Ze(e, n, t) {
+  return t.low <= n.lim && n.lim <= t.lim;
+}
+var dn = _t;
+function _t(e) {
+  let n = e.graph().ranker;
+  if (typeof n == "function") return n(e);
+  switch (n) {
+    case "network-simplex":
+      an(e);
+      break;
+    case "tight-tree":
+      Ct(e);
+      break;
+    case "longest-path":
+      Ot(e);
+      break;
+    case "none":
+      break;
+    default:
+      an(e);
+  }
+}
+var Ot = U;
+function Ct(e) {
+  U(e), ne(e);
+}
+function an(e) {
+  en(e);
+}
+var ln = Tt;
+function Tt(e) {
+  let n = Rt(e), t = e.graph();
+  if (!Array.isArray(t.dummyChains)) return;
+  t.dummyChains.forEach((o) => {
+    let i = e.node(o), s = i.edgeObj, a = jt(e, n, s.v, s.w), l = a.path, u = a.lca, d = 0, c = l[d], f = true;
+    for (; o !== s.w; ) {
+      if (i = e.node(o), f) {
+        for (; (c = l[d]) !== u && e.node(c).maxRank < i.rank; ) d++;
+        c === u && (f = false);
+      }
+      if (!f) {
+        for (; d < l.length - 1 && e.node(l[d + 1]).minRank <= i.rank; ) d++;
+        c = l[d];
+      }
+      c !== void 0 && e.setParent(o, c), o = e.successors(o)[0];
+    }
+  });
+}
+function jt(e, n, t, r) {
+  let o = [], i = [], s = Math.min(n[t].low, n[r].low), a = Math.max(n[t].lim, n[r].lim), l;
+  l = t;
+  do
+    l = e.parent(l), o.push(l);
+  while (l && (n[l].low > s || a > n[l].lim));
+  let u = l, d = r;
+  for (; (d = e.parent(d)) !== u; ) i.push(d);
+  return { path: o.concat(i.reverse()), lca: u };
+}
+function Rt(e) {
+  let n = {}, t = 0;
+  function r(o) {
+    let i = t;
+    e.children(o).forEach(r), n[o] = { low: i, lim: t++ };
+  }
+  return e.children(V).forEach(r), n;
+}
+function un(e) {
+  let n = M(e, "root", {}, "_root"), t = It(e), r = Object.values(t), o = S(Math.max, r) - 1, i = 2 * o + 1;
+  e.graph().nestingRoot = n, e.edges().forEach((a) => e.edge(a).minlen *= i);
+  let s = St(e) + 1;
+  e.children(V).forEach((a) => {
+    cn(e, n, i, s, o, t, a);
+  }), e.graph().nodeRankFactor = i;
+}
+function cn(e, n, t, r, o, i, s) {
+  var c;
+  let a = e.children(s);
+  if (!a.length) {
+    s !== n && e.setEdge(n, s, { weight: 0, minlen: t });
+    return;
+  }
+  let l = ae(e, "_bt"), u = ae(e, "_bb"), d = e.node(s);
+  e.setParent(l, s), d.borderTop = l, e.setParent(u, s), d.borderBottom = u, a.forEach((f) => {
+    var b;
+    cn(e, n, t, r, o, i, f);
+    let h = e.node(f), g = h.borderTop ? h.borderTop : f, m = h.borderBottom ? h.borderBottom : f, L = h.borderTop ? r : 2 * r, y = g !== m ? 1 : o - ((b = i[s]) != null ? b : 0) + 1;
+    e.setEdge(l, g, { weight: L, minlen: y, nestingEdge: true }), e.setEdge(m, u, { weight: L, minlen: y, nestingEdge: true });
+  }), e.parent(s) || e.setEdge(n, l, { weight: 0, minlen: o + ((c = i[s]) != null ? c : 0) });
+}
+function It(e) {
+  let n = {};
+  function t(r, o) {
+    let i = e.children(r);
+    i && i.length && i.forEach((s) => t(s, o + 1)), n[r] = o;
+  }
+  return e.children(V).forEach((r) => t(r, 1)), n;
+}
+function St(e) {
+  return e.edges().reduce((n, t) => n + e.edge(t).weight, 0);
+}
+function fn(e) {
+  let n = e.graph();
+  e.removeNode(n.nestingRoot), delete n.nestingRoot, e.edges().forEach((t) => {
+    e.edge(t).nestingEdge && e.removeEdge(t);
+  });
+}
+var bn = Pt;
+function Pt(e) {
+  function n(t) {
+    let r = e.children(t), o = e.node(t);
+    if (r.length && r.forEach(n), o && Object.hasOwn(o, "minRank")) {
+      o.borderLeft = [], o.borderRight = [];
+      for (let i = o.minRank, s = o.maxRank + 1; i < s; ++i) hn(e, "borderLeft", "_bl", t, o, i), hn(e, "borderRight", "_br", t, o, i);
+    }
+  }
+  e.children(V).forEach(n);
+}
+function hn(e, n, t, r, o, i) {
+  let s = { width: 0, height: 0, rank: i, borderType: n }, a = o[n][i - 1], l = M(e, "border", s, t);
+  o[n][i] = l, e.setParent(l, r), a && e.setEdge(a, l, { weight: 1 });
+}
+function pn(e) {
+  var t;
+  let n = (t = e.graph().rankdir) == null ? void 0 : t.toLowerCase();
+  (n === "lr" || n === "rl") && En(e);
+}
+function mn(e) {
+  var t;
+  let n = (t = e.graph().rankdir) == null ? void 0 : t.toLowerCase();
+  (n === "bt" || n === "rl") && Ft(e), (n === "lr" || n === "rl") && (Dt(e), En(e));
+}
+function En(e) {
+  e.nodes().forEach((n) => gn(e.node(n))), e.edges().forEach((n) => gn(e.edge(n)));
+}
+function gn(e) {
+  let n = e.width;
+  e.width = e.height, e.height = n;
+}
+function Ft(e) {
+  e.nodes().forEach((n) => me(e.node(n))), e.edges().forEach((n) => {
+    var r;
+    let t = e.edge(n);
+    (r = t.points) == null || r.forEach(me), Object.hasOwn(t, "y") && me(t);
+  });
+}
+function me(e) {
+  e.y = -e.y;
+}
+function Dt(e) {
+  e.nodes().forEach((n) => Ee(e.node(n))), e.edges().forEach((n) => {
+    var r;
+    let t = e.edge(n);
+    (r = t.points) == null || r.forEach(Ee), Object.hasOwn(t, "x") && Ee(t);
+  });
+}
+function Ee(e) {
+  let n = e.x;
+  e.x = e.y, e.y = n;
+}
+function Le(e, n = null) {
+  let t = {}, r = e.nodes().filter((d) => !e.children(d).length), o = r.map((d) => e.node(d).rank), i = S(Math.max, o), s = D(i + 1).map(() => []);
+  function a(d) {
+    if (t[d]) return;
+    t[d] = true;
+    let c = e.node(d);
+    s[c.rank].push(d);
+    let f = e.successors(d);
+    f && [...f].sort((g, m) => u(g, m)).forEach(a);
+  }
+  r.sort((d, c) => e.node(d).rank - e.node(c).rank).forEach(a);
+  function u(d, c) {
+    let f = e.node(d), h = e.node(c);
+    return ee(n, f, h);
+  }
+  return s;
+}
+function ye(e, n) {
+  let t = 0;
+  for (let r = 1; r < n.length; ++r) t += Vt(e, n[r - 1], n[r]);
+  return t;
+}
+function Vt(e, n, t) {
+  let r = He(t, t.map((u, d) => d)), o = n.flatMap((u) => {
+    let d = e.outEdges(u);
+    return d ? d.map((c) => ({ pos: r[c.w], weight: e.edge(c).weight })).sort((c, f) => c.pos - f.pos) : [];
+  }), i = 1;
+  for (; i < t.length; ) i <<= 1;
+  let s = 2 * i - 1;
+  i -= 1;
+  let a = new Array(s).fill(0), l = 0;
+  return o.forEach((u) => {
+    let d = u.pos + i;
+    a[d] += u.weight;
+    let c = 0;
+    for (; d > 0; ) d % 2 && (c += a[d + 1]), d = d - 1 >> 1, a[d] += u.weight;
+    l += u.weight * c;
+  }), l;
+}
+function we(e, n = []) {
+  return n.map((t) => {
+    let r = e.inEdges(t);
+    if (!r || !r.length) return { v: t };
+    {
+      let o = r.reduce((i, s) => {
+        let a = e.edge(s), l = e.node(s.v);
+        return { sum: i.sum + a.weight * l.order, weight: i.weight + a.weight };
+      }, { sum: 0, weight: 0 });
+      return { v: t, barycenter: o.sum / o.weight, weight: o.weight };
+    }
+  });
+}
+function Ne(e, n) {
+  let t = {};
+  e.forEach((o, i) => {
+    let s = { indegree: 0, in: [], out: [], vs: [o.v], i };
+    o.barycenter !== void 0 && (s.barycenter = o.barycenter, s.weight = o.weight), t[o.v] = s;
+  }), n.edges().forEach((o) => {
+    let i = t[o.v], s = t[o.w];
+    i !== void 0 && s !== void 0 && (s.indegree++, i.out.push(s));
+  });
+  let r = Object.values(t).filter((o) => !o.indegree);
+  return Yt(r);
+}
+function Yt(e) {
+  let n = [];
+  function t(o) {
+    return (i) => {
+      i.merged || (i.barycenter === void 0 || o.barycenter === void 0 || i.barycenter >= o.barycenter) && Bt(o, i);
+    };
+  }
+  function r(o) {
+    return (i) => {
+      i.in.push(o), --i.indegree === 0 && e.push(i);
+    };
+  }
+  for (; e.length; ) {
+    let o = e.pop();
+    n.push(o), o.in.reverse().forEach(t(o)), o.out.forEach(r(o));
+  }
+  return n.filter((o) => !o.merged).map((o) => W(o, ["vs", "i", "barycenter", "weight"]));
+}
+function Bt(e, n) {
+  let t = 0, r = 0;
+  e.weight && (t += e.barycenter * e.weight, r += e.weight), n.weight && (t += n.barycenter * n.weight, r += n.weight), e.vs = n.vs.concat(e.vs), e.barycenter = t / r, e.weight = r, e.i = Math.min(n.i, e.i), n.merged = true;
+}
+function Ge(e, n, t, r, o) {
+  let i = {}, s = null, a = null, l = o;
+  typeof n == "boolean" ? (l = n, i = {}) : n && (i = n, s = t != null ? t : null, a = r != null ? r : null);
+  let u = ze(e, (y) => Object.hasOwn(y, "barycenter")), d = u.lhs, c = u.rhs.sort((y, b) => b.i - y.i), f = [], h = 0, g = 0, m = 0;
+  d.sort(Wt(a, s, !!l));
+  for (let [y, b] of Object.entries(i)) {
+    let p = d.findIndex((E) => E.vs[0] === y);
+    d.splice(p + 1, 0, b);
+  }
+  m = Ln(f, c, m), d.forEach((y) => {
+    m += y.vs.length, f.push(y.vs), h += y.barycenter * y.weight, g += y.weight, m = Ln(f, c, m);
+  });
+  let L = { vs: f.flat(1) };
+  return g && (L.barycenter = h / g, L.weight = g), L;
+}
+function Ln(e, n, t) {
+  let r;
+  for (; n.length && (r = n[n.length - 1]).i <= t; ) n.pop(), e.push(r.vs), t++;
+  return t;
+}
+function Wt(e, n, t) {
+  return (r, o) => {
+    if (r.barycenter < o.barycenter) return -1;
+    if (r.barycenter > o.barycenter) return 1;
+    if (e && (typeof r.vs[0] == "string" || typeof o.vs[0] == "string")) {
+      let i = e.node(r.vs[0]), s = e.node(o.vs[0]), a = ee(n, i, s);
+      if (a !== 0) return a;
+    }
+    return t ? o.i - r.i : r.i - o.i;
+  };
+}
+function te(e, n, t, r, o) {
+  var y, b, p, E, w, k, _, O, j, R, I;
+  let i = null, s = o;
+  typeof r == "boolean" ? (s = r, i = null) : r !== void 0 && (i = r);
+  let a = e.children(n), l = e.node(n), u = l ? l.borderLeft : void 0, d = l ? l.borderRight : void 0, c = {};
+  u && (a = a.filter((v) => v !== u && v !== d));
+  let f = we(e, a);
+  f.forEach((v) => {
+    if (e.children(v.v).length) {
+      let { result: x } = te(e, v.v, t, i, s);
+      c[v.v] = x, Object.hasOwn(x, "barycenter") && zt(v, x);
+    }
+  });
+  let h = Ne(f, t);
+  Xt(h, c);
+  let g = {}, m = false;
+  for (let v = 0; v < h.length; v++) for (let x = v + 1; x < h.length; x++) if (!(!h[v] || !h[x] || !((y = h[v]) != null && y.barycenter) || !((b = h[x]) != null && b.barycenter)) && ((p = h[v]) == null ? void 0 : p.barycenter) === h[x].barycenter) {
+    let G = (w = (E = h[v]) == null ? void 0 : E.vs[0]) != null ? w : "", N = (_ = (k = h[x]) == null ? void 0 : k.vs[0]) != null ? _ : "", C = e.node(G), B = e.node(N);
+    if (C.dummy === "edge" && B.dummy === "edge" && ((O = C.edgeObj) == null ? void 0 : O.v) === ((j = B.edgeObj) == null ? void 0 : j.v) && ((R = C.edgeObj) == null ? void 0 : R.w) === ((I = B.edgeObj) == null ? void 0 : I.w)) if (C.edgeLabel.reversed) {
+      g[N] = h[v], h.splice(v, 1), v--;
+      break;
+    } else g[G] || (g[G] = h[x], h.splice(x, 1), x--);
+    else m = true;
+  }
+  let L = Ge(h, g, i, e, s);
+  if (u && d) {
+    L.vs = [u, L.vs, d].flat(1);
+    let v = e.predecessors(u);
+    if (v && v.length) {
+      let x = e.node(v[0]), G = e.predecessors(d), N = e.node(G[0]);
+      Object.hasOwn(L, "barycenter") || (L.barycenter = 0, L.weight = 0), L.barycenter = (L.barycenter * L.weight + x.order + N.order) / (L.weight + 2), L.weight += 2;
+    }
+  }
+  return Object.defineProperty(L, "result", { value: L, enumerable: false, configurable: true, writable: true }), Object.defineProperty(L, "usedBias", { value: m, enumerable: false, configurable: true, writable: true }), L;
+}
+function Xt(e, n) {
+  e.forEach((t) => {
+    t.vs = t.vs.flatMap((r) => n[r] ? n[r].vs : r);
+  });
+}
+function zt(e, n) {
+  e.barycenter !== void 0 ? (e.barycenter = (e.barycenter * e.weight + n.barycenter * n.weight) / (e.weight + n.weight), e.weight += n.weight) : (e.barycenter = n.barycenter, e.weight = n.weight);
+}
+function ve(e, n, t, r) {
+  r || (r = e.nodes());
+  let o = Ht(e), i = new T({ compound: true }).setGraph({ root: o }).setDefaultNodeLabel((s) => e.node(s));
+  return r.forEach((s) => {
+    let a = e.node(s), l = e.parent(s);
+    if (a.rank === n || a.minRank <= n && n <= a.maxRank) {
+      i.setNode(s), i.setParent(s, l || o);
+      let u = e[t](s);
+      u && u.forEach((d) => {
+        let c = d.v === s ? d.w : d.v, f = i.edge(c, s), h = f !== void 0 ? f.weight : 0;
+        i.setEdge(c, s, { weight: e.edge(d).weight + h });
+      }), Object.hasOwn(a, "minRank") && i.setNode(s, { borderLeft: a.borderLeft[n], borderRight: a.borderRight[n] });
+    }
+  }), i;
+}
+function Ht(e) {
+  let n;
+  for (; e.hasNode(n = $("_root")); ) ;
+  return n;
+}
+function ke(e, n, t) {
+  let r = {}, o;
+  t.forEach((i) => {
+    let s = e.parent(i), a, l;
+    for (; s; ) {
+      if (a = e.parent(s), a ? (l = r[a], r[a] = s) : (l = o, o = s), l && l !== s) {
+        n.setEdge(l, s);
+        return;
+      }
+      s = a;
+    }
+  });
+}
+function re(e, n = {}, t = null) {
+  if (typeof n.customOrder == "function") {
+    n.customOrder(e, re);
+    return;
+  }
+  let r = de(e), o = yn(e, D(1, r + 1), "inEdges"), i = yn(e, D(r - 1, -1, -1), "outEdges"), s = Le(e, t);
+  if (wn(e, s), n.disableOptimalOrderHeuristic) return;
+  let a = Number.POSITIVE_INFINITY, l, u = n.constraints || [];
+  for (let d = 0, c = 0; c < 4; ++d, ++c) {
+    qt(d % 2 ? o : i, d % 4 >= 2, u, t), s = P(e);
+    let f = ye(e, s);
+    f < a ? (c = 0, l = Object.assign({}, s), a = f) : f === a && (l = structuredClone(s));
+  }
+  wn(e, l);
+}
+function yn(e, n, t) {
+  let r = /* @__PURE__ */ new Map(), o = (i, s) => {
+    r.has(i) || r.set(i, []), r.get(i).push(s);
+  };
+  for (let i of e.nodes()) {
+    let s = e.node(i);
+    if (typeof s.rank == "number" && o(s.rank, i), typeof s.minRank == "number" && typeof s.maxRank == "number") for (let a = s.minRank; a <= s.maxRank; a++) a !== s.rank && o(a, i);
+  }
+  return n.map(function(i) {
+    return ve(e, i, t, r.get(i) || []);
+  });
+}
+function qt(e, n, t, r) {
+  let o = true, i = new T();
+  e.forEach(function(s) {
+    t.forEach((d) => i.setEdge(d.left, d.right));
+    let a = s.graph().root, { result: l, usedBias: u } = te(s, a, i, r, o);
+    n && u && (o = !o), l.vs.forEach((d, c) => s.node(d).order = c), ke(s, i, l.vs);
+  });
+}
+function wn(e, n) {
+  Object.values(n).forEach((t) => t.forEach((r, o) => e.node(r).order = o));
+}
+function $t(e, n) {
+  let t = {};
+  function r(o, i) {
+    let s = 0, a = 0, l = o.length, u = i[i.length - 1];
+    return i.forEach((d, c) => {
+      let f = Jt(e, d), h = f ? e.node(f).order : l;
+      (f || d === u) && (i.slice(a, c + 1).forEach((g) => {
+        let m = e.predecessors(g);
+        m && m.forEach((L) => {
+          let y = e.node(L), b = y.order;
+          (b < s || h < b) && !(y.dummy && e.node(g).dummy) && Gn(t, L, g);
+        });
+      }), a = c + 1, s = h);
+    }), i;
+  }
+  return n.length && n.reduce(r), t;
+}
+function Ut(e, n) {
+  let t = {};
+  function r(a) {
+    var l;
+    return ((l = e.node(a)) == null ? void 0 : l.dummy) === "border";
+  }
+  if (!e.nodes().some(r)) return t;
+  function i(a, l, u, d, c) {
+    D(l, u).forEach((f) => {
+      let h = a[f];
+      if (h !== void 0 && e.node(h).dummy) {
+        let g = e.predecessors(h);
+        g && g.forEach((m) => {
+          if (m === void 0) return;
+          let L = e.node(m);
+          L.dummy && (L.order < d || L.order > c) && Gn(t, m, h);
+        });
+      }
+    });
+  }
+  function s(a, l) {
+    let u = -1, d = -1, c = 0;
+    return l.forEach((f, h) => {
+      if (r(f)) {
+        let g = e.predecessors(f);
+        if (g && g.length) {
+          let m = g[0];
+          if (m === void 0) return;
+          d = e.node(m).order, i(l, c, h, u, d), c = h, u = d;
+        }
+      }
+      i(l, c, l.length, d, a.length);
+    }), l;
+  }
+  return n.length && n.reduce(s), t;
+}
+function Jt(e, n) {
+  if (e.node(n).dummy) {
+    let t = e.predecessors(n);
+    if (t) return t.find((r) => e.node(r).dummy);
+  }
+}
+function Gn(e, n, t) {
+  if (n > t) {
+    let o = n;
+    n = t, t = o;
+  }
+  let r = e[n];
+  r || (e[n] = r = {}), r[t] = true;
+}
+function Kt(e, n, t) {
+  if (n > t) {
+    let o = n;
+    n = t, t = o;
+  }
+  let r = e[n];
+  return r !== void 0 && Object.hasOwn(r, t);
+}
+function Qt(e, n, t, r, o) {
+  let i = {}, s = {}, a = {};
+  return n.forEach((l) => {
+    l.forEach((u, d) => {
+      i[u] = u, s[u] = u, a[u] = d;
+    });
+  }), n.forEach((l) => {
+    let u = -1, d = -1, c = false, f = l, h = l.findIndex((g) => (o == null ? void 0 : o.includes(g)) || Nn(g, e, o));
+    h > 0 && (f = [l[h], ...l.slice(0, h), ...l.slice(h + 1)], c = true), f.forEach((g) => {
+      var L;
+      let m = r(g);
+      if (m && m.length) {
+        o != null && o.includes(g) && (m = m.filter((p) => Nn(p, e, o)));
+        let y = m.sort((p, E) => {
+          let w = a[p], k = a[E];
+          return (w !== void 0 ? w : 0) - (k !== void 0 ? k : 0);
+        }), b = (y.length - 1) / 2;
+        for (let p = Math.floor(b), E = Math.ceil(b); p <= E; ++p) {
+          let w = y[p];
+          if (w === void 0) continue;
+          let k = a[w];
+          if (k !== void 0 && s[g] === g && u < k && a[w] !== d && !Kt(t, g, w)) {
+            let _ = i[w];
+            _ !== void 0 && (s[w] = g, s[g] = i[g] = _, u = k, c && (u = -1, d = (L = a[w]) != null ? L : -1, c = false));
+          }
+        }
+      }
+    });
+  }), { root: i, align: s };
+}
+function Zt(e, n, t, r, o = false) {
+  let i = {}, s = er(e, n, t, o), a = o ? "borderLeft" : "borderRight";
+  function l(h, g) {
+    let m = s.nodes().slice(), L = {}, y = m.pop();
+    for (; y; ) {
+      if (L[y]) h(y);
+      else {
+        L[y] = true, m.push(y);
+        for (let b of g(y)) m.push(b);
+      }
+      y = m.pop();
+    }
+  }
+  function u(h) {
+    let g = s.inEdges(h);
+    g ? i[h] = g.reduce((m, L) => {
+      var p;
+      let y = (p = i[L.v]) != null ? p : 0, b = s.edge(L);
+      return Math.max(m, y + (b !== void 0 ? b : 0));
+    }, 0) : i[h] = 0;
+  }
+  function d(h) {
+    let g = s.outEdges(h), m = Number.POSITIVE_INFINITY;
+    g && (m = g.reduce((y, b) => {
+      let p = i[b.w], E = s.edge(b);
+      return Math.min(y, (p !== void 0 ? p : 0) - (E !== void 0 ? E : 0));
+    }, Number.POSITIVE_INFINITY));
+    let L = e.node(h);
+    m !== Number.POSITIVE_INFINITY && L.borderType !== a && (i[h] = Math.max(i[h] !== void 0 ? i[h] : 0, m));
+  }
+  function c(h) {
+    return s.predecessors(h) || [];
+  }
+  function f(h) {
+    return s.successors(h) || [];
+  }
+  return l(u, c), l(d, f), Object.keys(r).forEach((h) => {
+    var m;
+    let g = t[h];
+    g !== void 0 && (i[h] = (m = i[g]) != null ? m : 0);
+  }), i;
+}
+function er(e, n, t, r) {
+  let o = new T(), i = e.graph(), s = or(i.nodesep, i.edgesep, r);
+  return n.forEach((a) => {
+    let l;
+    a.forEach((u) => {
+      let d = t[u];
+      if (d !== void 0) {
+        if (o.setNode(d), l !== void 0) {
+          let c = t[l];
+          if (c !== void 0) {
+            let f = o.edge(c, d);
+            o.setEdge(c, d, Math.max(s(e, u, l), f || 0));
+          }
+        }
+        l = u;
+      }
+    });
+  }), o;
+}
+function nr(e, n) {
+  return Object.values(n).reduce((t, r) => {
+    let o = Number.NEGATIVE_INFINITY, i = Number.POSITIVE_INFINITY;
+    Object.entries(r).forEach(([a, l]) => {
+      let u = ir(e, a) / 2;
+      o = Math.max(l + u, o), i = Math.min(l - u, i);
+    });
+    let s = o - i;
+    return s < t[0] && (t = [s, r]), t;
+  }, [Number.POSITIVE_INFINITY, null])[1];
+}
+function tr(e, n) {
+  let t = Object.values(n), r = S(Math.min, t), o = S(Math.max, t);
+  ["u", "d"].forEach((i) => {
+    ["l", "r"].forEach((s) => {
+      let a = i + s, l = e[a];
+      if (!l || l === n) return;
+      let u = Object.values(l), d = r - S(Math.min, u);
+      s !== "l" && (d = o - S(Math.max, u)), d && (e[a] = X(l, (c) => c + d));
+    });
+  });
+}
+function rr(e, n = void 0) {
+  let t = e.ul;
+  return t ? X(t, (r, o) => {
+    var s, a;
+    if (n) {
+      let l = n.toLowerCase(), u = e[l];
+      if (u && u[o] !== void 0) return u[o];
+    }
+    let i = Object.values(e).map((l) => {
+      let u = l[o];
+      return u !== void 0 ? u : 0;
+    }).sort((l, u) => l - u);
+    return (((s = i[1]) != null ? s : 0) + ((a = i[2]) != null ? a : 0)) / 2;
+  }) : {};
+}
+function vn(e, n) {
+  let t = P(e), r = Object.assign($t(e, t), Ut(e, t)), o = {}, i;
+  ["u", "d"].forEach((a) => {
+    i = a === "u" ? t : Object.values(t).reverse(), ["l", "r"].forEach((l) => {
+      l === "r" && (i = i.map((f) => Object.values(f).reverse()));
+      let d = Qt(e, i, r, (f) => (a === "u" ? e.predecessors(f) : e.successors(f)) || [], n), c = Zt(e, i, d.root, d.align, l === "r");
+      l === "r" && (c = X(c, (f) => -f)), o[a + l] = c;
+    });
+  });
+  let s = nr(e, o);
+  return tr(o, s), rr(o, e.graph().align);
+}
+function or(e, n, t) {
+  return (r, o, i) => {
+    let s = r.node(o), a = r.node(i), l = 0, u;
+    if (l += s.width / 2, Object.hasOwn(s, "labelpos")) switch (s.labelpos.toLowerCase()) {
+      case "l":
+        u = -s.width / 2;
+        break;
+      case "r":
+        u = s.width / 2;
+        break;
+    }
+    if (u && (l += t ? u : -u), u = void 0, l += (s.dummy ? n : e) / 2, l += (a.dummy ? n : e) / 2, l += a.width / 2, Object.hasOwn(a, "labelpos")) switch (a.labelpos.toLowerCase()) {
+      case "l":
+        u = a.width / 2;
+        break;
+      case "r":
+        u = -a.width / 2;
+        break;
+    }
+    return u && (l += t ? u : -u), l;
+  };
+}
+function ir(e, n) {
+  return e.node(n).width;
+}
+function Nn(e, n, t) {
+  var s;
+  if (!t) return false;
+  let r = (s = n.node(e)) == null ? void 0 : s.edgeObj;
+  if (!r || n.node(e).edgeLabel.reversed) return false;
+  let o = t.indexOf(r == null ? void 0 : r.v), i = t.indexOf(r == null ? void 0 : r.w);
+  return o !== -1 && i !== -1 && o === (i + 1) % t.length || o === (i - 1) % t.length;
+}
+function kn(e, n) {
+  e = Z(e), sr(e), Object.entries(vn(e, n)).forEach(([t, r]) => e.node(t).x = r);
+}
+function sr(e) {
+  let n = P(e), t = e.graph(), r = t.ranksep, o = t.rankalign, i = 0;
+  n.forEach((s) => {
+    let a = s.reduce((l, u) => {
+      var c;
+      let d = (c = e.node(u).height) != null ? c : 0;
+      return l > d ? l : d;
+    }, 0);
+    s.forEach((l) => {
+      let u = e.node(l);
+      o === "top" ? u.y = i + u.height / 2 : o === "bottom" ? u.y = i + a - u.height / 2 : u.y = i + a / 2;
+    }), i += a + r;
+  });
+}
+var xn = /* @__PURE__ */ new WeakMap();
+function Oe(e, n = {}) {
+  return In(e, q, n), e;
+}
+function _n(e, n, t) {
+  let r = n;
+  for (; r !== void 0; ) {
+    let o = e.parent(r);
+    if (o === t) return r;
+    r = o;
+  }
+}
+function In(e, n, t) {
+  var y;
+  let r = e.nodes().filter((b) => e.children(b).length), o = {};
+  r.forEach((b) => {
+    let p = e.node(b);
+    if (p && p.rankdir) {
+      let E = new T({ multigraph: true, compound: true });
+      E.setGraph({ rankdir: p.rankdir });
+      let w = e.children(b);
+      w.forEach((G) => {
+        let N = { ...e.node(G) };
+        E.setNode(G, N);
+        let C = e.parent(G);
+        C && C !== b && w.includes(C) && E.setParent(G, C);
+      });
+      let k = /* @__PURE__ */ new Set();
+      e.edges().forEach((G) => {
+        let N = _n(e, G.v, b), C = _n(e, G.w, b);
+        if (N === G.v && C === G.w) E.setEdge(G, { ...e.edge(G) });
+        else if (N && C && N !== C) {
+          let B = `${N}\0${C}`;
+          k.has(B) || (k.add(B), E.setEdge(N, C, { ...e.edge(G) }));
+        }
+      }), In(E, n, t);
+      let _ = Rn(E);
+      Cn(_, n, t, null), Tn(E, _);
+      let O = 1 / 0, j = 1 / 0, R = -1 / 0, I = -1 / 0;
+      E.nodes().forEach((G) => {
+        if (G === b) return;
+        let N = E.node(G);
+        N && typeof N.x == "number" && typeof N.y == "number" && typeof N.width == "number" && typeof N.height == "number" && (O = Math.min(O, N.x - N.width / 2), R = Math.max(R, N.x + N.width / 2), j = Math.min(j, N.y - N.height / 2), I = Math.max(I, N.y + N.height / 2));
+      }), (!isFinite(O) || !isFinite(j) || !isFinite(R) || !isFinite(I)) && (O = j = 0, R = I = 0);
+      let v = R - O, x = I - j;
+      o[b] = { minX: O, minY: j, maxX: R, maxY: I, width: v, height: x, offsetX: O, offsetY: j }, p._dagreClusterSubgraph = E;
+    }
+  });
+  let i = [], s = (b) => {
+    let p = [], E = (e.children(b) || []).filter((w) => w !== b);
+    for (; E.length > 0; ) {
+      let w = E.shift();
+      p.push(w), (e.children(w) || []).filter((k) => k !== w).forEach((k) => E.push(k));
+    }
+    return p;
+  }, a = /* @__PURE__ */ new Map();
+  r.forEach((b) => {
+    let p = e.node(b);
+    p && p.rankdir && o[b] && a.set(b, (e.children(b) || []).filter((E) => E !== b));
+  });
+  let l = new Set([...a.values()].flat()), u = /* @__PURE__ */ new Map();
+  a.forEach((b, p) => {
+    l.has(p) || u.set(p, s(p));
+  });
+  let d = new Set([...u.values()].flat()), c = (b) => {
+    for (let [p, E] of u) if (E.includes(b)) return p;
+    return b;
+  }, f = [];
+  e.edges().forEach((b) => {
+    (d.has(b.v) || d.has(b.w)) && f.push({ edge: b, label: e.edge(b) });
+  });
+  let h = /* @__PURE__ */ new Map();
+  d.forEach((b) => {
+    let p = e.parent(b);
+    h.set(b, typeof p == "string" ? p : void 0);
+  }), u.forEach((b, p) => {
+    let E = e.node(p), w = [];
+    b.forEach((O) => {
+      let j = e.node(O);
+      j && (w.push({ id: O, node: j, parent: h.get(O) }), e.removeNode(O));
+    });
+    let k = f.filter(({ edge: O }) => b.includes(O.v) || b.includes(O.w)), _ = o[p];
+    E && (i.push({ clusterId: p, subgraph: E._dagreClusterSubgraph, bounds: _, children: b, removedNodes: w, removedEdges: k }), E.width = _.width, E.height = _.height);
+  });
+  let g = /* @__PURE__ */ new Set();
+  f.forEach(({ edge: b, label: p }) => {
+    let E = c(b.v), w = c(b.w);
+    if (E !== w && e.hasNode(E) && e.hasNode(w)) {
+      let k = `${E}\0${w}`;
+      g.has(k) || (g.add(k), e.setEdge(E, w, { ...p, width: 0, height: 0 }));
+    }
+  });
+  let m = Rn(e), L = Cn(m, n, t, (y = xn.get(e)) != null ? y : null);
+  xn.set(e, L), Tn(e, m), g.forEach((b) => {
+    let p = b.indexOf("\0"), E = b.slice(0, p), w = b.slice(p + 1);
+    e.hasEdge(E, w) && e.removeEdge(E, w);
+  }), i.forEach(({ clusterId: b, subgraph: p, bounds: E, removedNodes: w, removedEdges: k }) => {
+    var v, x;
+    let _ = e.node(b), O = (v = _ == null ? void 0 : _.x) != null ? v : 0, j = (x = _ == null ? void 0 : _.y) != null ? x : 0, R = (E.minX + E.maxX) / 2, I = (E.minY + E.maxY) / 2;
+    w.forEach(({ id: G, node: N, parent: C }) => {
+      e.setNode(G, N), C !== void 0 && e.setParent(G, C);
+    }), k.forEach(({ edge: G, label: N }) => {
+      e.setEdge(G, N);
+    }), p.nodes().forEach((G) => {
+      if (G === b) return;
+      let N = p.node(G), C = e.node(G);
+      C && N && typeof N.x == "number" && typeof N.y == "number" && (C.x = O + (N.x - R), C.y = j + (N.y - I));
+    }), On(e, p, O - R, j - I), delete _._dagreClusterSubgraph;
+  }), r.forEach((b) => {
+    var w, k;
+    let p = e.node(b), E = o[b];
+    if (p && p.rankdir && p._dagreClusterSubgraph && E) {
+      let _ = p._dagreClusterSubgraph, O = (w = p.x) != null ? w : 0, j = (k = p.y) != null ? k : 0, R = (E.minX + E.maxX) / 2, I = (E.minY + E.maxY) / 2;
+      _.nodes().forEach((v) => {
+        if (v === b) return;
+        let x = _.node(v), G = e.node(v);
+        if (G && x && typeof x.x == "number" && typeof x.y == "number") {
+          let N = x.x - R, C = x.y - I;
+          G.x = O + N, G.y = j + C;
+        }
+      }), On(e, _, O - R, j - I), delete p._dagreClusterSubgraph;
+    }
+  });
+}
+function On(e, n, t, r) {
+  n.edges().forEach((o) => {
+    if (!e.hasEdge(o)) return;
+    let i = n.edge(o), s = e.edge(o);
+    s.points = i.points.map((a) => ({ x: a.x + t, y: a.y + r })), Object.hasOwn(i, "x") && (s.x = i.x + t, s.y = i.y + r);
+  });
+}
+function Cn(e, n, t, r = null) {
+  var l, u;
+  let o = (t == null ? void 0 : t.useDynamic) !== false, i = o && (l = r == null ? void 0 : r.graph) != null ? l : null, s = o && (u = r == null ? void 0 : r.rawNodes) != null ? u : null;
+  n("    makeSpaceForEdgeLabels", () => br(e)), n("    removeSelfEdges", () => Gr(e)), n("    acyclic", () => Ue(e, i)), n("    nestingGraph.run", () => un(e)), n("    rank", () => dn(Z(e))), n("    injectEdgeLabelProxies", () => gr(e)), n("    removeEmptyRanks", () => We(e)), n("    nestingGraph.cleanup", () => fn(e)), n("    normalizeRanks", () => Be(e)), n("    assignRankMinMax", () => pr(e)), n("    removeEdgeLabelProxies", () => mr(e)), n("    normalize.run", () => Ke(e)), n("    parentDummyChains", () => ln(e)), n("    addBorderSegments", () => bn(e)), n("    order", () => re(e, t, s)), n("    insertSelfEdges", () => vr(e)), n("    adjustCoordinateSystem", () => pn(e)), n("    position", () => kn(e, t.corePath)), n("    positionSelfEdges", () => kr(e));
+  let a = JSON.parse(JSON.stringify(e._nodes));
+  return n("    removeBorderNodes", () => Nr(e)), n("    normalize.undo", () => Qe(e)), n("    fixupEdgeLabelCoords", () => yr(e)), n("    undoCoordinateSystem", () => mn(e)), n("    translateGraph", () => Er(e)), n("    assignNodeIntersects", () => Lr(e)), n("    reversePoints", () => wr(e)), n("    acyclic.undo", () => Je(e)), { graph: e, rawNodes: a };
+}
+function Tn(e, n) {
+  e.nodes().forEach((t) => {
+    let r = e.node(t), o = n.node(t);
+    r && (r.x = o.x, r.y = o.y, r.order = o.order, r.rank = o.rank, n.children(t).length && (r.width = o.width, r.height = o.height));
+  }), e.edges().forEach((t) => {
+    let r = e.edge(t), o = n.edge(t);
+    r.points = o.points, Object.hasOwn(o, "x") && (r.x = o.x, r.y = o.y);
+  }), e.graph().width = n.graph().width, e.graph().height = n.graph().height;
+}
+var ar = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
+var dr = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "TB", rankalign: "center" };
+var lr = ["acyclicer", "ranker", "rankdir", "align", "rankalign"];
+var ur = ["width", "height", "rank"];
+var jn = { width: 0, height: 0 };
+var cr = ["minlen", "weight", "width", "height", "labeloffset"];
+var fr = { minlen: 1, weight: 1, width: 0, height: 0, labeloffset: 10, labelpos: "r" };
+var hr = ["labelpos"];
+function Rn(e) {
+  let n = new T({ multigraph: true, compound: true }), t = _e(e.graph());
+  return n.setGraph(Object.assign({}, dr, xe(t, ar), W(t, lr))), e.nodes().forEach((r) => {
+    let o = _e(e.node(r)), i = xe(o, ur);
+    Object.keys(jn).forEach((a) => {
+      i[a] === void 0 && (i[a] = jn[a]);
+    }), n.setNode(r, i);
+    let s = e.parent(r);
+    s !== void 0 && n.setParent(r, s);
+  }), e.edges().forEach((r) => {
+    let o = _e(e.edge(r));
+    n.setEdge(r, Object.assign({}, fr, xe(o, cr), W(o, hr)));
+  }), n;
+}
+function br(e) {
+  let n = e.graph();
+  n.ranksep /= 2, e.edges().forEach((t) => {
+    var o;
+    let r = e.edge(t);
+    r.minlen *= 2, ((o = r.labelpos) != null ? o : "r").toLowerCase() !== "c" && (n.rankdir === "TB" || n.rankdir === "BT" ? r.width += r.labeloffset : r.height += r.labeloffset);
+  });
+}
+function gr(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n);
+    if (t.width && t.height) {
+      let r = e.node(n.v), i = { rank: (e.node(n.w).rank - r.rank) / 2 + r.rank, e: n };
+      M(e, "edge-proxy", i, "_ep");
+    }
+  });
+}
+function pr(e) {
+  let n = 0;
+  e.nodes().forEach((t) => {
+    let r = e.node(t);
+    r.borderTop && (r.minRank = e.node(r.borderTop).rank, r.maxRank = e.node(r.borderBottom).rank, n = Math.max(n, r.maxRank));
+  }), e.graph().maxRank = n;
+}
+function mr(e) {
+  e.nodes().forEach((n) => {
+    let t = e.node(n);
+    if (t.dummy === "edge-proxy") {
+      let r = t;
+      e.edge(r.e).labelRank = t.rank, e.removeNode(n);
+    }
+  });
+}
+function Er(e) {
+  let n = Number.POSITIVE_INFINITY, t = 0, r = Number.POSITIVE_INFINITY, o = 0, i = e.graph(), s = i.marginx || 0, a = i.marginy || 0;
+  function l(u) {
+    let d = u.x, c = u.y, f = u.width, h = u.height;
+    n = Math.min(n, d - f / 2), t = Math.max(t, d + f / 2), r = Math.min(r, c - h / 2), o = Math.max(o, c + h / 2);
+  }
+  e.nodes().forEach((u) => l(e.node(u))), e.edges().forEach((u) => {
+    let d = e.edge(u);
+    Object.hasOwn(d, "x") && l(d);
+  }), n -= s, r -= a, e.nodes().forEach((u) => {
+    let d = e.node(u);
+    d.x -= n, d.y -= r;
+  }), e.edges().forEach((u) => {
+    let d = e.edge(u);
+    d.points.forEach((c) => {
+      c.x -= n, c.y -= r;
+    }), Object.hasOwn(d, "x") && (d.x -= n), Object.hasOwn(d, "y") && (d.y -= r);
+  }), i.width = t - n + s, i.height = o - r + a;
+}
+function Lr(e) {
+  e.edges().forEach((n) => {
+    if (n.v === n.w) return;
+    let t = e.edge(n), r = e.node(n.v), o = e.node(n.w), i, s;
+    t.points ? (i = t.points[0], s = t.points[t.points.length - 1]) : (t.points = [], i = o, s = r), t.points.unshift(se(r, i)), t.points.push(se(o, s));
+  });
+}
+function yr(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n);
+    if (Object.hasOwn(t, "x")) switch ((t.labelpos === "l" || t.labelpos === "r") && (t.width -= t.labeloffset), t.labelpos) {
+      case "l":
+        t.x -= t.width / 2 + t.labeloffset;
+        break;
+      case "r":
+        t.x += t.width / 2 + t.labeloffset;
+        break;
+    }
+  });
+}
+function wr(e) {
+  e.edges().forEach((n) => {
+    let t = e.edge(n);
+    t.reversed && t.points.reverse();
+  });
+}
+function Nr(e) {
+  e.nodes().forEach((n) => {
+    if (e.children(n).length) {
+      let t = e.node(n), r = e.node(t.borderTop), o = e.node(t.borderBottom), i = e.node(t.borderLeft[t.borderLeft.length - 1]), s = e.node(t.borderRight[t.borderRight.length - 1]);
+      t.width = Math.abs(s.x - i.x), t.height = Math.abs(o.y - r.y), t.x = i.x + t.width / 2, t.y = r.y + t.height / 2;
+    }
+  }), e.nodes().forEach((n) => {
+    e.node(n).dummy === "border" && e.removeNode(n);
+  });
+}
+function Gr(e) {
+  e.edges().forEach((n) => {
+    if (n.v === n.w) {
+      let t = e.node(n.v);
+      t.selfEdges || (t.selfEdges = []), t.selfEdges.push({ e: n, label: e.edge(n) }), e.removeEdge(n);
+    }
+  });
+}
+function vr(e) {
+  P(e).forEach((t) => {
+    let r = 0;
+    t.forEach((o, i) => {
+      let s = e.node(o);
+      typeof s.rank != "number" && (s.rank = 0), s.order = i + r, (s.selfEdges || []).forEach((a) => {
+        M(e, "selfedge", { width: a.label.width, height: a.label.height, rank: s.rank, order: i + ++r, e: a.e, edgeLabel: a.label }, "_se"), (!Array.isArray(a.label.points) || a.label.points.length !== 7) && (a.label.points = [{ x: 0, y: -10 }, { x: 0, y: -10 }, { x: 0, y: 0 }, { x: 0, y: 10 }, { x: 0, y: 10 }, { x: 0, y: 0 }, { x: 0, y: 0 }]);
+      }), delete s.selfEdges;
+    });
+  });
+}
+function kr(e) {
+  e.nodes().forEach((n) => {
+    let t = e.node(n), r = (o) => typeof o == "number" && isFinite(o);
+    if (t.dummy === "selfedge") {
+      let o = t, i = e.node(o.e.v), s = r(i == null ? void 0 : i.x) ? i.x : 0, a = r(i == null ? void 0 : i.y) ? i.y : 0, l = r(i == null ? void 0 : i.width) ? i.width : 0, u = r(i == null ? void 0 : i.height) ? i.height : 0, d = r(t.x) ? t.x : s, c = r(t.y) ? t.y : a, f = l / 2, h = u / 2;
+      o.edgeLabel.points = [{ x: d + f, y: c - h }, { x: d + f, y: c - h }, { x: d, y: c }, { x: d - f, y: c + h }, { x: d - f, y: c + h }, { x: d, y: c }, { x: d, y: c }], o.edgeLabel.x = d, o.edgeLabel.y = c, e.setEdge(o.e, o.edgeLabel), e.removeNode(n);
+    } else t && Array.isArray(t.selfEdges) && t.selfEdges.forEach((o) => {
+      if (!Array.isArray(o.label.points) || o.label.points.length !== 7) {
+        let i = r(t.x) ? t.x : 0, s = r(t.y) ? t.y : 0, a = r(t.width) ? t.width : 0, l = r(t.height) ? t.height : 0, u = a / 2, d = l / 2;
+        o.label.points = [{ x: i + u, y: s - d }, { x: i + u, y: s - d }, { x: i, y: s }, { x: i - u, y: s + d }, { x: i - u, y: s + d }, { x: i, y: s }, { x: i, y: s }];
+      }
+    });
+  });
+}
+function xe(e, n) {
+  return X(W(e, n), Number);
+}
+function _e(e) {
+  let n = {};
+  return e && Object.entries(e).forEach(([t, r]) => {
+    typeof t == "string" && (t = t.toLowerCase()), n[t] = r;
+  }), n;
+}
+function Ce(e) {
+  let n = P(e), t = new T({ compound: true, multigraph: true }).setGraph({});
+  return e.nodes().forEach((r) => {
+    t.setNode(r, { label: r }), t.setParent(r, "layer" + e.node(r).rank);
+  }), e.edges().forEach((r) => t.setEdge(r.v, r.w, {}, r.name)), n.forEach((r, o) => {
+    let i = "layer" + o;
+    t.setNode(i, { rank: "same" }), r.reduce((s, a) => (t.setEdge(s, a, { style: "invis" }), a));
+  }), t;
+}
+var xr = { graphlib: ie, version: ue, layout: Oe, debug: Ce, util: { time: le, notime: q } };
+var Uo = xr;
+
+// src/runtime/components/_architecture-lanes.js
+var LANES = {
+  margin: 16,
+  // around the drawing
+  lanePad: 14,
+  // inside a lane frame
+  head: 30,
+  // lane heading band
+  headSize: 12,
+  // lane heading text
+  colGap: 18,
+  // between boxes side by side in a lane
+  rowGap: 34,
+  // between rows; grows when routes need more tracks
+  gutter: 52,
+  // between lanes; grows with labels and routes
+  bottom: 18,
+  // routing channel under the last row, inside the lanes
+  track: 9,
+  // spacing of parallel lines in a channel
+  clear: 9,
+  // routes keep this far from boxes
+  stub: 14,
+  // straight run out of a port before any bend
+  laneMinW: 170,
+  laneMaxHeadW: 300
+};
+function runLanes(model) {
+  const plan = planColumns(model);
+  if (!plan) return null;
+  if (!plan.layout) plan.layout = routeWithGrowth(model, plan.sizes, () => placeColumns(plan.lanes, plan.byId, plan.rowCount, plan.sizes, model));
+  return plan.layout;
+}
+function lanesPlanWidth(model) {
+  return planColumns(model)?.width ?? 0;
+}
+var plans = /* @__PURE__ */ new WeakMap();
+function planColumns(model) {
+  if (plans.has(model)) return plans.get(model);
+  const lanes = prepareLanes(model);
+  if (!lanes) {
+    plans.set(model, null);
+    return null;
+  }
+  const byId = new Map(model.nodes.map((n) => [n.id, n]));
+  const rowCount = assignGlobalRows(lanes, model.edges);
+  const sizes = /* @__PURE__ */ new Map();
+  initialGutters(lanes, model.edges).forEach((g, i) => sizes.set(`g${i}`, g));
+  const rowOf = /* @__PURE__ */ new Map();
+  for (const lane of lanes) for (const [g, ids] of lane.phys) for (const id of ids) rowOf.set(id, { g, lane });
+  for (const e of model.edges) {
+    const a = rowOf.get(e.from);
+    const b = rowOf.get(e.to);
+    const lb = sizeEdgeLabel(e.label);
+    if (!a || !b || !lb || a.lane !== b.lane || Math.abs(a.g - b.g) !== 1) continue;
+    const key = `r${Math.min(a.g, b.g)}`;
+    sizes.set(key, Math.max(sizes.get(key) ?? LANES.rowGap, lb.height + 30));
+  }
+  const plan = { lanes, byId, rowCount, sizes, width: placeColumns(lanes, byId, rowCount, sizes, model).width, layout: null };
+  plans.set(model, plan);
+  return plan;
+}
+function runStackedLanes(model, targetWidth) {
+  const lanes = prepareLanes(model);
+  if (!lanes) return null;
+  assignGlobalRows(lanes, model.edges);
+  for (const lane of lanes) lane.rows.sort((a, b) => a.g - b.g);
+  const byId = new Map(model.nodes.map((n) => [n.id, n]));
+  const sizes = /* @__PURE__ */ new Map([
+    ["left", 22],
+    ["right", 22]
+  ]);
+  const layout = routeWithGrowth(model, sizes, () => placeBands(lanes, byId, sizes, model, targetWidth), STACKED_MAX_CHANNEL);
+  if (layout) layout.rankdir = "stacked";
+  return layout;
+}
+var STACKED_MAX_CHANNEL = 22 + 6 * 9;
+function prepareLanes(model) {
+  const lanes = assignLanes(model);
+  if (!lanes) return null;
+  const byId = new Map(model.nodes.map((n) => [n.id, n]));
+  for (const lane of lanes) lane.rows = applyPins(laneRows(lane, model.edges), byId);
+  return lanes;
+}
+function routeWithGrowth(model, sizes, place, maxSize = Infinity) {
+  let result = null;
+  for (let pass = 0; pass < 2; pass++) {
+    const geo = place();
+    const routed = routeAll(geo, model);
+    result = { geo, routed };
+    const grow = channelShortfall(geo, routed);
+    let changed = false;
+    for (const [key, need] of grow) {
+      const next = Math.min(maxSize, Math.max(sizes.get(key) || 0, need));
+      if (next > (sizes.get(key) || 0)) {
+        sizes.set(key, next);
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  return finish(result, model);
+}
+function assignLanes(model) {
+  const top = model.groups.filter((g) => !g.parent);
+  if (!top.length) return null;
+  const laneOf = /* @__PURE__ */ new Map();
+  const lanes = top.map((group) => ({ group, nodes: [] }));
+  for (const lane of lanes) {
+    for (const m of lane.group.members) {
+      if (laneOf.has(m)) continue;
+      laneOf.set(m, lane);
+      lane.nodes.push(m);
+    }
+  }
+  const loose = model.nodes.map((n) => n.id).filter((id) => !laneOf.has(id));
+  if (loose.length) {
+    const isLoose = new Set(loose);
+    let out = 0;
+    let inn = 0;
+    for (const e of model.edges) {
+      if (isLoose.has(e.from) && !isLoose.has(e.to)) out++;
+      if (!isLoose.has(e.from) && isLoose.has(e.to)) inn++;
+    }
+    const lane = { group: null, nodes: loose };
+    for (const id of loose) laneOf.set(id, lane);
+    if (out >= inn) lanes.unshift(lane);
+    else lanes.push(lane);
+  }
+  lanes.forEach((lane, i) => {
+    lane.index = i;
+  });
+  for (const lane of lanes) lane.laneOf = laneOf;
+  return lanes;
+}
+function laneRows(lane, edges) {
+  const ids = lane.nodes;
+  const pos = new Map(ids.map((id, i) => [id, i]));
+  const inLane = (id) => pos.has(id);
+  const intra = edges.filter((e) => e.from !== e.to && inLane(e.from) && inLane(e.to));
+  const parent = new Map(ids.map((id) => [id, id]));
+  const find = (x) => {
+    while (parent.get(x) !== x) {
+      parent.set(x, parent.get(parent.get(x)));
+      x = parent.get(x);
+    }
+    return x;
+  };
+  for (const e of intra) parent.set(find(e.from), find(e.to));
+  const adj = new Map(ids.map((id) => [id, []]));
+  for (const e of intra) adj.get(e.from).push(e.to);
+  const state = /* @__PURE__ */ new Map();
+  const kept = [];
+  for (const root of ids) {
+    if (state.get(root)) continue;
+    const stack = [[root, 0]];
+    state.set(root, 1);
+    while (stack.length) {
+      const top = stack[stack.length - 1];
+      const [u, k] = top;
+      const next = adj.get(u)[k];
+      if (next === void 0) {
+        state.set(u, 2);
+        stack.pop();
+        continue;
+      }
+      top[1]++;
+      if (state.get(next) === 1) continue;
+      kept.push([u, next]);
+      if (!state.get(next)) {
+        state.set(next, 1);
+        stack.push([next, 0]);
+      }
+    }
+  }
+  const rank = new Map(ids.map((id) => [id, 0]));
+  for (let changed = true, guard = 0; changed && guard <= ids.length; guard++) {
+    changed = false;
+    for (const [u, v] of kept) {
+      if (rank.get(v) < rank.get(u) + 1) {
+        rank.set(v, rank.get(u) + 1);
+        changed = true;
+      }
+    }
+  }
+  const blocks = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const root = find(id);
+    if (!blocks.has(root)) blocks.set(root, []);
+    blocks.get(root).push(id);
+  }
+  const rows = [];
+  for (const members2 of [...blocks.values()].sort((a, b) => pos.get(a[0]) - pos.get(b[0]))) {
+    const byRank = /* @__PURE__ */ new Map();
+    for (const id of members2) {
+      const r = rank.get(id);
+      if (!byRank.has(r)) byRank.set(r, []);
+      byRank.get(r).push(id);
+    }
+    for (const r of [...byRank.keys()].sort((a, b) => a - b)) {
+      const ids2 = byRank.get(r);
+      if (ids2.length <= 2) rows.push({ ids: ids2, pin: null });
+      else for (const id of ids2) rows.push({ ids: [id], pin: null });
+    }
+  }
+  return rows;
+}
+function applyPins(rows, byId) {
+  const out = [];
+  const pinned = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const free = [];
+    for (const id of row.ids) {
+      const pin = byId.get(id)?.row;
+      if (!pin) {
+        free.push(id);
+        continue;
+      }
+      if (!pinned.has(pin)) {
+        const pr2 = { ids: [], pin };
+        pinned.set(pin, pr2);
+        out.push(pr2);
+      }
+      pinned.get(pin).ids.push(id);
+    }
+    if (free.length) out.push({ ids: free, pin: null });
+  }
+  return out;
+}
+function isotonic(values, weights) {
+  const blocks = [];
+  for (let k = 0; k < values.length; k++) {
+    blocks.push({ s: values[k] * weights[k], w: weights[k], n: 1 });
+    while (blocks.length > 1) {
+      const b = blocks[blocks.length - 1];
+      const a = blocks[blocks.length - 2];
+      if (a.s / a.w <= b.s / b.w) break;
+      a.s += b.s;
+      a.w += b.w;
+      a.n += b.n;
+      blocks.pop();
+    }
+  }
+  const out = [];
+  for (const b of blocks) for (let k = 0; k < b.n; k++) out.push(b.s / b.w);
+  return out;
+}
+function assignGlobalRows(lanes, edges) {
+  const rowOf = /* @__PURE__ */ new Map();
+  for (const lane of lanes) for (const r of lane.rows) for (const id of r.ids) rowOf.set(id, r);
+  const laneOf = lanes[0].laneOf;
+  const neighbors = /* @__PURE__ */ new Map();
+  const link = (a, b) => {
+    if (!neighbors.has(a)) neighbors.set(a, []);
+    neighbors.get(a).push(b);
+  };
+  for (const e of edges) {
+    const a = rowOf.get(e.from);
+    const b = rowOf.get(e.to);
+    if (!a || !b || laneOf.get(e.from) === laneOf.get(e.to)) continue;
+    link(a, b);
+    link(b, a);
+  }
+  for (const lane of lanes) lane.rows.forEach((r, i) => r.g = r.pin ?? i + 1);
+  for (let sweep = 0; sweep < 8; sweep++) {
+    for (const lane of sweep % 2 ? [...lanes].reverse() : lanes) {
+      const free = lane.rows.filter((r) => !r.pin);
+      const taken = new Set(lane.rows.filter((r) => r.pin).map((r) => r.pin));
+      const want = [];
+      const weight = [];
+      free.forEach((r, i) => {
+        const ns = neighbors.get(r);
+        want.push(ns ? ns.reduce((sum, x) => sum + x.g, 0) / ns.length - (i + 1) : 0);
+        weight.push(ns ? ns.length : 0.05);
+      });
+      const fit = isotonic(want, weight);
+      let prev = 0;
+      free.forEach((r, i) => {
+        let g = Math.max(prev + 1, Math.max(0, Math.round(fit[i])) + i + 1);
+        while (taken.has(g)) g++;
+        r.g = g;
+        prev = g;
+      });
+    }
+  }
+  const used = [...new Set(lanes.flatMap((l) => l.rows.map((r) => r.g)))].sort((a, b) => a - b);
+  const index = new Map(used.map((g, i) => [g, i]));
+  for (const lane of lanes) {
+    lane.phys = /* @__PURE__ */ new Map();
+    for (const r of lane.rows) {
+      const g = index.get(r.g);
+      if (!lane.phys.has(g)) lane.phys.set(g, []);
+      lane.phys.get(g).push(...r.ids);
+    }
+  }
+  return used.length;
+}
+var GUTTER_LABEL_W = 96;
+function initialGutters(lanes, edges) {
+  const laneOf = lanes[0].laneOf;
+  const gutters = new Array(Math.max(0, lanes.length - 1)).fill(LANES.gutter);
+  const crossing = new Array(gutters.length).fill(0);
+  for (const e of edges) {
+    const a = laneOf.get(e.from)?.index;
+    const b = laneOf.get(e.to)?.index;
+    if (a === void 0 || b === void 0 || a === b) continue;
+    const lo = Math.min(a, b);
+    const hi = Math.max(a, b);
+    for (let i = lo; i < hi; i++) crossing[i]++;
+    const lb = sizeEdgeLabel(e.label);
+    if (lb) {
+      const g = b > a ? a : a - 1;
+      gutters[g] = Math.max(gutters[g], (narrowLabel(e.label, GUTTER_LABEL_W)?.width ?? lb.width) + 22);
+    }
+  }
+  return gutters.map((g, i) => Math.max(g, 24 + crossing[i] * LANES.track));
+}
+function sizeLaneHeads(lanes, inner) {
+  for (const lane of lanes) {
+    const label = lane.group?.label || "";
+    lane.headLine = label ? wrapText(label, LANES.headSize, inner(lane), 1, true)[0] : "";
+  }
+}
+function placeColumns(lanes, byId, rowCount, sizes, model) {
+  const L = LANES;
+  const natural = new Map(model.nodes.map((n) => [n.id, sizeNode(n)]));
+  const nested = model.groups.some((g) => g.parent);
+  const headH = (lanes.some((l) => l.group?.label) ? L.head : 0) + (nested ? 16 : 0);
+  const gutter = (i) => sizes.get(`g${i}`) ?? L.gutter;
+  const rowGap = (g) => sizes.get(`r${g}`) ?? L.rowGap;
+  for (const lane of lanes) {
+    let inner = L.laneMinW;
+    for (const ids of lane.phys.values()) {
+      const w = ids.reduce((sum, id) => sum + natural.get(id).width, 0) + L.colGap * (ids.length - 1);
+      inner = Math.max(inner, w);
+    }
+    const label = lane.group?.label || "";
+    if (label) inner = Math.max(inner, Math.min(textWidth(label, L.headSize, true) + 4, L.laneMaxHeadW));
+    lane.inner = inner;
+  }
+  sizeLaneHeads(lanes, (lane) => lane.inner);
+  const sized = /* @__PURE__ */ new Map();
+  for (const lane of lanes) {
+    for (const ids of lane.phys.values()) {
+      const sum = ids.reduce((acc, id) => acc + natural.get(id).width, 0);
+      const extra = (lane.inner - sum - L.colGap * (ids.length - 1)) / ids.length;
+      for (const id of ids) sized.set(id, sizeNode(byId.get(id), Math.floor(natural.get(id).width + extra)));
+    }
+  }
+  const rowH = new Array(rowCount).fill(0);
+  for (const lane of lanes) for (const [g, ids] of lane.phys) for (const id of ids) rowH[g] = Math.max(rowH[g], sized.get(id).height);
+  const rowTop = [];
+  let y = L.margin + headH + L.lanePad;
+  for (let g = 0; g < rowCount; g++) {
+    rowTop[g] = y;
+    y += rowH[g] + (g < rowCount - 1 ? rowGap(g) : 0);
+  }
+  const contentBottom = y;
+  const frameTop = L.margin;
+  const frameBottom = contentBottom + L.bottom + L.lanePad;
+  let x = L.margin;
+  const boxes = /* @__PURE__ */ new Map();
+  for (const lane of lanes) {
+    const w = lane.inner + L.lanePad * 2;
+    lane.frame = { x, y: frameTop, w, h: frameBottom - frameTop };
+    for (const [g, ids] of lane.phys) {
+      let bx = x + L.lanePad;
+      for (const id of ids) {
+        const b = sized.get(id);
+        boxes.set(id, { ...b, x: bx, y: Math.round(rowTop[g] + (rowH[g] - b.height) / 2), rowIndex: g, laneIndex: lane.index });
+        bx += b.width + L.colGap;
+      }
+    }
+    x += w + (lane.index < lanes.length - 1 ? gutter(lane.index) : 0);
+  }
+  const width = x + L.margin;
+  const height = frameBottom + L.margin;
+  const channels = [];
+  lanes.forEach((lane, i) => {
+    if (i < lanes.length - 1) channels.push({ key: `g${i}`, axis: "x", lo: lane.frame.x + lane.frame.w, hi: lanes[i + 1].frame.x });
+  });
+  for (let g = 0; g < rowCount - 1; g++) channels.push({ key: `r${g}`, axis: "y", lo: rowTop[g] + rowH[g], hi: rowTop[g + 1] });
+  channels.push({ key: "bottom", axis: "y", lo: contentBottom, hi: frameBottom - 4, fixed: true });
+  channels.push({ key: "outL", axis: "x", lo: 0, hi: L.margin, fixed: true }, { key: "outR", axis: "x", lo: width - L.margin, hi: width, fixed: true });
+  channels.push({ key: "outB", axis: "y", lo: frameBottom, hi: height, fixed: true });
+  const frameLines = { xs: lanes.flatMap((l) => [l.frame.x, l.frame.x + l.frame.w]), ys: [frameTop, frameBottom] };
+  const sides = (e) => {
+    const a = boxes.get(e.from);
+    const b = boxes.get(e.to);
+    if (a.laneIndex !== b.laneIndex) return b.laneIndex > a.laneIndex ? ["right", "left"] : ["left", "right"];
+    if (b.rowIndex > a.rowIndex) return ["bottom", "top"];
+    if (b.rowIndex < a.rowIndex) return ["top", "bottom"];
+    return b.x > a.x ? ["right", "left"] : ["left", "right"];
+  };
+  return { lanes, boxes, channels, frameLines, sides, width, height };
+}
+function placeBands(lanes, byId, sizes, model, targetWidth) {
+  const L = LANES;
+  const left = sizes.get("left");
+  const right = sizes.get("right");
+  const target = (targetWidth || 360) / 0.85;
+  const room = Math.max(180, Math.min(720, target - left - right - L.lanePad * 2 - 4));
+  sizeLaneHeads(lanes, () => room);
+  const boxes = /* @__PURE__ */ new Map();
+  const channels = [];
+  const x0 = left + L.lanePad;
+  let y = L.margin;
+  let seq2 = 0;
+  let prevBottom = null;
+  let prevLine = [];
+  const nested = model.groups.some((g) => g.parent);
+  for (const lane of lanes) {
+    const top = y;
+    y += (lane.headLine ? L.head : 0) + (nested ? 16 : 0) + L.lanePad;
+    if (prevBottom !== null) channels.push({ key: `band${lane.index}`, axis: "y", lo: prevBottom, hi: top, fixed: true });
+    let first = true;
+    for (const row of lane.rows) {
+      const natural = row.ids.map((id) => sizeNode(byId.get(id)));
+      const fits = natural.reduce((sum, n) => sum + n.width, 0) + L.colGap * (row.ids.length - 1) <= room;
+      const lines = fits ? [row.ids] : row.ids.map((id) => [id]);
+      for (const ids of lines) {
+        if (!first) {
+          let gap = sizes.get(`s${seq2}`) ?? 30;
+          for (const e of model.edges) {
+            const lb = sizeEdgeLabel(e.label);
+            if (!lb) continue;
+            const pair = (p, q2) => prevLine.includes(p) && ids.includes(q2);
+            if (pair(e.from, e.to) || pair(e.to, e.from)) gap = Math.max(gap, lb.height + 30);
+          }
+          channels.push({ key: `s${seq2}`, axis: "y", lo: y, hi: y + gap });
+          y += gap;
+        }
+        first = false;
+        const w = (room - L.colGap * (ids.length - 1)) / ids.length;
+        const sized = ids.map((id) => sizeNode(byId.get(id), Math.floor(w)));
+        const h = Math.max(...sized.map((b) => b.height));
+        let bx = x0;
+        ids.forEach((id, k) => {
+          boxes.set(id, { ...sized[k], x: bx, y: Math.round(y + (h - sized[k].height) / 2), rowIndex: seq2, laneIndex: lane.index });
+          bx += sized[k].width + L.colGap;
+        });
+        y += h;
+        seq2++;
+        prevLine = ids;
+      }
+    }
+    y += L.lanePad;
+    lane.frame = { x: left, y: top, w: room + L.lanePad * 2, h: y - top };
+    prevBottom = y;
+    y += 26;
+  }
+  const width = left + room + L.lanePad * 2 + right;
+  const height = prevBottom + L.margin;
+  channels.push({ key: "left", axis: "x", lo: 0, hi: left }, { key: "right", axis: "x", lo: width - right, hi: width });
+  const frameLines = { xs: [left, width - right], ys: lanes.flatMap((l) => [l.frame.y, l.frame.y + l.frame.h]) };
+  const sides = (e) => {
+    const a = boxes.get(e.from);
+    const b = boxes.get(e.to);
+    if (a.rowIndex === b.rowIndex) return b.x > a.x ? ["right", "left"] : ["left", "right"];
+    if (b.rowIndex === a.rowIndex + 1 && b.x < a.x + a.width && a.x < b.x + b.width) return ["bottom", "top"];
+    return b.rowIndex > a.rowIndex ? ["right", "right"] : ["left", "left"];
+  };
+  return { lanes, boxes, channels, frameLines, sides, width, height };
+}
+function trackPositions(lo, hi) {
+  const room = hi - lo - 12;
+  if (room < 0) return [(lo + hi) / 2];
+  const n = Math.min(SEARCH.maxTracks, Math.floor(room / LANES.track) + 1);
+  const mid = (lo + hi) / 2;
+  return Array.from({ length: n }, (_, k) => mid + (k - (n - 1) / 2) * LANES.track);
+}
+function routeAll(geo, model) {
+  const { boxes } = geo;
+  const edges = [];
+  const loops = [];
+  for (const e of model.edges) {
+    if (!boxes.has(e.from) || !boxes.has(e.to)) continue;
+    if (e.from === e.to) {
+      loops.push(e);
+      continue;
+    }
+    const [fromSide, toSide] = geo.sides(e);
+    const a = boxes.get(e.from);
+    const b = boxes.get(e.to);
+    edges.push({ id: e.id, from: e.from, to: e.to, fromSide: openSide(a, fromSide, b, boxes), toSide: openSide(b, toSide, a, boxes) });
+  }
+  const xs = [];
+  const ys = [];
+  for (const c of geo.channels) (c.axis === "x" ? xs : ys).push(...trackPositions(c.lo, c.hi));
+  const routes = routeOrthogonal({
+    boxes,
+    edges,
+    xLines: xs,
+    yLines: ys,
+    avoid: geo.frameLines,
+    bounds: { x0: 1, y0: 1, x1: geo.width - 1, y1: geo.height - 1 }
+  });
+  for (const e of loops) {
+    const b = boxes.get(e.from);
+    const r = b.x + b.width;
+    const bottom = b.y + b.height;
+    routes.set(e.id, [
+      { x: r - 30, y: bottom },
+      { x: r - 30, y: bottom + 14 },
+      { x: r + 12, y: bottom + 14 },
+      { x: r + 12, y: bottom - 14 },
+      { x: r, y: bottom - 14 }
+    ]);
+  }
+  return routes;
+}
+function openSide(box, side, other, boxes) {
+  const reach = LANES.stub + LANES.clear + 2;
+  const blocked = (sd) => {
+    for (const o of boxes.values()) {
+      if (o === box) continue;
+      const ySpan = o.y < box.y + box.height && box.y < o.y + o.height;
+      const xSpan = o.x < box.x + box.width && box.x < o.x + o.width;
+      if (sd === "right" && ySpan && o.x >= box.x + box.width && o.x - (box.x + box.width) < reach) return true;
+      if (sd === "left" && ySpan && o.x + o.width <= box.x && box.x - (o.x + o.width) < reach) return true;
+      if (sd === "bottom" && xSpan && o.y >= box.y + box.height && o.y - (box.y + box.height) < reach) return true;
+      if (sd === "top" && xSpan && o.y + o.height <= box.y && box.y - (o.y + o.height) < reach) return true;
+    }
+    return false;
+  };
+  if (!blocked(side)) return side;
+  const towardY = other.y + other.height / 2 >= box.y + box.height / 2 ? ["bottom", "top"] : ["top", "bottom"];
+  const towardX = other.x + other.width / 2 >= box.x + box.width / 2 ? ["right", "left"] : ["left", "right"];
+  const order = side === "left" || side === "right" ? towardY : towardX;
+  return order.find((sd) => !blocked(sd)) || side;
+}
+function channelShortfall(geo, routes) {
+  const vertical = [];
+  const horizontal = [];
+  for (const pts of routes.values()) {
+    for (let i = 1; i < pts.length; i++) {
+      const a = pts[i - 1];
+      const b = pts[i];
+      if (a.x === b.x && a.y !== b.y) vertical.push(a.x);
+      else if (a.y === b.y && a.x !== b.x) horizontal.push(a.y);
+    }
+  }
+  const need = /* @__PURE__ */ new Map();
+  for (const c of geo.channels) {
+    if (c.fixed) continue;
+    const lines = c.axis === "x" ? vertical : horizontal;
+    const used = new Set(lines.filter((v) => v > c.lo && v < c.hi).map((v) => Math.round(v))).size;
+    if (used >= trackPositions(c.lo, c.hi).length) need.set(c.key, 24 + (used + 2) * LANES.track);
+  }
+  return need;
+}
+var NORMAL = { left: [-1, 0], right: [1, 0], top: [0, -1], bottom: [0, 1] };
+function placePorts(boxes, edges) {
+  const sides = /* @__PURE__ */ new Map();
+  const add = (node2, side, other, edge, end) => {
+    const key = `${node2}\0${side}`;
+    if (!sides.has(key)) sides.set(key, { node: node2, side, items: [] });
+    sides.get(key).items.push({ other, edge, end });
+  };
+  for (const e of edges) {
+    add(e.from, e.fromSide, e.to, e, "fromPort");
+    add(e.to, e.toSide, e.from, e, "toPort");
+  }
+  for (const { node: node2, side, items } of sides.values()) {
+    const b = boxes.get(node2);
+    const horizontal = side === "left" || side === "right";
+    const lo = horizontal ? b.y + 9 : b.x + 12;
+    const hi = horizontal ? b.y + b.height - 9 : b.x + b.width - 12;
+    for (const it2 of items) {
+      const o = boxes.get(it2.other);
+      const oLo = horizontal ? o.y : o.x;
+      const oHi = horizontal ? o.y + o.height : o.x + o.width;
+      const sLo = horizontal ? b.y : b.x;
+      const sHi = horizontal ? b.y + b.height : b.x + b.width;
+      const overlap = Math.min(oHi, sHi) - Math.max(oLo, sLo);
+      const want = overlap > 18 ? (Math.min(oHi, sHi) + Math.max(oLo, sLo)) / 2 : (oLo + oHi) / 2;
+      it2.want = Math.min(hi, Math.max(lo, want));
+    }
+    items.sort((a, c) => a.want - c.want);
+    const gap = Math.min(14, items.length > 1 ? (hi - lo) / (items.length - 1) : 14);
+    let prev = -Infinity;
+    for (const it2 of items) {
+      it2.pos = Math.max(it2.want, prev + gap);
+      prev = it2.pos;
+    }
+    const over = prev - hi;
+    if (over > 0) {
+      let next = Infinity;
+      for (let k = items.length - 1; k >= 0; k--) {
+        items[k].pos = Math.min(items[k].pos, hi, next - gap);
+        next = items[k].pos;
+      }
+    }
+    for (const it2 of items) {
+      const pos = Math.round(it2.pos);
+      const p = horizontal ? { x: side === "left" ? b.x : b.x + b.width, y: pos } : { x: pos, y: side === "top" ? b.y : b.y + b.height };
+      it2.edge[it2.end] = p;
+    }
+  }
+}
+var Heap = class {
+  constructor() {
+    this.k = [];
+    this.v = [];
+  }
+  push(item, key) {
+    const { k, v } = this;
+    let i = k.length;
+    k.push(key);
+    v.push(item);
+    while (i > 0) {
+      const p = i - 1 >> 1;
+      if (k[p] <= key) break;
+      k[i] = k[p];
+      v[i] = v[p];
+      i = p;
+    }
+    k[i] = key;
+    v[i] = item;
+  }
+  /** Pops the smallest; its key is left in this.top. */
+  pop() {
+    const { k, v } = this;
+    const item = v[0];
+    this.top = k[0];
+    const lastK = k.pop();
+    const lastV = v.pop();
+    const n = k.length;
+    if (n) {
+      let i = 0;
+      for (; ; ) {
+        const l = i * 2 + 1;
+        if (l >= n) break;
+        const m = l + 1 < n && k[l + 1] < k[l] ? l + 1 : l;
+        if (k[m] >= lastK) break;
+        k[i] = k[m];
+        v[i] = v[m];
+        i = m;
+      }
+      k[i] = lastK;
+      v[i] = lastV;
+    }
+    return item;
+  }
+  get size() {
+    return this.k.length;
+  }
+};
+var COST = { bend: 36, overlap: 8, cross: 22, hug: 0.6 };
+var SEARCH = { weight: 1.5, maxSteps: 12e4, maxTracks: 14 };
+function routeOrthogonal({ boxes, edges, xLines = [], yLines = [], avoid = { xs: [], ys: [] }, bounds }) {
+  const C = LANES.clear;
+  const S2 = LANES.stub;
+  placePorts(boxes, edges);
+  const stubOf = (p, side) => ({ x: p.x + NORMAL[side][0] * S2, y: p.y + NORMAL[side][1] * S2 });
+  const rnd = (v) => Math.round(v * 2) / 2;
+  const hugXs = /* @__PURE__ */ new Set();
+  const hugYs = /* @__PURE__ */ new Set();
+  const xsAll = [...xLines];
+  const ysAll = [...yLines];
+  for (const b of boxes.values()) {
+    xsAll.push(b.x - C, b.x + b.width + C);
+    ysAll.push(b.y - C, b.y + b.height + C);
+    hugXs.add(rnd(b.x - C)).add(rnd(b.x + b.width + C));
+    hugYs.add(rnd(b.y - C)).add(rnd(b.y + b.height + C));
+  }
+  for (const x of avoid.xs) hugXs.add(rnd(x));
+  for (const y of avoid.ys) hugYs.add(rnd(y));
+  for (const e of edges) {
+    for (const [p, side] of [
+      [e.fromPort, e.fromSide],
+      [e.toPort, e.toSide]
+    ]) {
+      const st2 = stubOf(p, side);
+      xsAll.push(p.x, st2.x);
+      ysAll.push(p.y, st2.y);
+    }
+  }
+  const uniq = (arr, lo, hi) => [...new Set(arr.map(rnd))].filter((v) => v >= lo && v <= hi).sort((a, b) => a - b);
+  const xs = uniq(xsAll, bounds.x0, bounds.x1);
+  const ys = uniq(ysAll, bounds.y0, bounds.y1);
+  const nx = xs.length;
+  const ny = ys.length;
+  const xi = new Map(xs.map((v, i) => [v, i]));
+  const yi = new Map(ys.map((v, i) => [v, i]));
+  const ix = (v) => xi.get(rnd(v));
+  const iy = (v) => yi.get(rnd(v));
+  const hugX = Uint8Array.from(xs, (x) => hugXs.has(x) ? 1 : 0);
+  const hugY = Uint8Array.from(ys, (y) => hugYs.has(y) ? 1 : 0);
+  const hBlock = new Uint8Array(nx * ny);
+  const vBlock = new Uint8Array(nx * ny);
+  const firstAbove = (arr, v) => {
+    let lo = 0;
+    let hi = arr.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (arr[mid] > v) hi = mid;
+      else lo = mid + 1;
+    }
+    return lo;
+  };
+  for (const b of boxes.values()) {
+    const x0 = b.x - C;
+    const x1 = b.x + b.width + C;
+    const y0 = b.y - C;
+    const y1 = b.y + b.height + C;
+    const iA = firstAbove(xs, x0);
+    const iB = firstAbove(xs, x1 - 1e-9);
+    const jA = firstAbove(ys, y0);
+    const jB = firstAbove(ys, y1 - 1e-9);
+    for (let j = jA; j < jB; j++) {
+      for (let i = Math.max(0, iA - 1); i < Math.min(nx - 1, iB); i++) {
+        const mx = (xs[i] + xs[i + 1]) / 2;
+        if (mx > x0 && mx < x1) hBlock[j * nx + i] = 1;
+      }
+    }
+    for (let i = iA; i < iB; i++) {
+      for (let j = Math.max(0, jA - 1); j < Math.min(ny - 1, jB); j++) {
+        const my = (ys[j] + ys[j + 1]) / 2;
+        if (my > y0 && my < y1) vBlock[j * nx + i] = 1;
+      }
+    }
+  }
+  const hUse = new Uint16Array(nx * ny);
+  const vUse = new Uint16Array(nx * ny);
+  const hPass = new Uint16Array(nx * ny);
+  const vPass = new Uint16Array(nx * ny);
+  const N = nx * ny * 4;
+  const dist = new Float64Array(N);
+  const prev = new Int32Array(N);
+  const seen = new Uint32Array(N);
+  let stamp = 0;
+  const DX = [1, -1, 0, 0];
+  const DY = [0, 0, 1, -1];
+  const dirOf = (side) => ({ right: 0, left: 1, bottom: 2, top: 3 })[side];
+  const reverse = [1, 0, 3, 2];
+  const routes = /* @__PURE__ */ new Map();
+  const order = [...edges].sort(
+    (a, b) => Math.abs(a.fromPort.x - a.toPort.x) + Math.abs(a.fromPort.y - a.toPort.y) - (Math.abs(b.fromPort.x - b.toPort.x) + Math.abs(b.fromPort.y - b.toPort.y))
+  );
+  const solid = [...boxes.entries()];
+  for (const e of order) {
+    const a = e.fromPort;
+    const b = e.toPort;
+    if ((a.x === b.x || a.y === b.y) && dirOf(e.fromSide) === reverse[dirOf(e.toSide)] && towards(a, b, e.fromSide)) {
+      const seg = { x0: Math.min(a.x, b.x), y0: Math.min(a.y, b.y), x1: Math.max(a.x, b.x), y1: Math.max(a.y, b.y) };
+      const blocked = solid.some(([id, r]) => id !== e.from && id !== e.to && seg.x0 < r.x + r.width && r.x < seg.x1 && seg.y0 < r.y + r.height && r.y < seg.y1);
+      if (!blocked) {
+        routes.set(e.id, [a, b]);
+        const path7 = [];
+        const [i0, j0, i1, j1] = [ix(a.x), iy(a.y), ix(b.x), iy(b.y)];
+        if (j0 === j1) for (let i = Math.min(i0, i1); i <= Math.max(i0, i1); i++) path7.push([i, j0]);
+        else for (let j = Math.min(j0, j1); j <= Math.max(j0, j1); j++) path7.push([i0, j]);
+        if (path7.every(([i, j]) => i !== void 0 && j !== void 0)) mark(path7);
+        continue;
+      }
+    }
+    const st2 = stubOf(e.fromPort, e.fromSide);
+    const tt2 = stubOf(e.toPort, e.toSide);
+    const si = ix(st2.x);
+    const sj = iy(st2.y);
+    const ti = ix(tt2.x);
+    const tj = iy(tt2.y);
+    let path6 = null;
+    if (si !== void 0 && sj !== void 0 && ti !== void 0 && tj !== void 0) {
+      path6 = search(si, sj, dirOf(e.fromSide), ti, tj, reverse[dirOf(e.toSide)]);
+    }
+    const pts = path6 ? path6.map(([i, j]) => ({ x: xs[i], y: ys[j] })) : elbow(st2, tt2, e.fromSide);
+    if (path6) mark(path6);
+    routes.set(e.id, simplify([e.fromPort, ...pts, e.toPort]));
+  }
+  return routes;
+  function search(si, sj, sd, ti, tj, endDir) {
+    stamp++;
+    const W2 = SEARCH.weight;
+    const tx = xs[ti];
+    const ty = ys[tj];
+    const heap = new Heap();
+    const start = (sj * nx + si) * 4 + sd;
+    dist[start] = 0;
+    prev[start] = -1;
+    seen[start] = stamp;
+    heap.push(start, W2 * (Math.abs(xs[si] - tx) + Math.abs(ys[sj] - ty)));
+    let best = -1;
+    let bestCost = Infinity;
+    let steps2 = 0;
+    while (heap.size) {
+      const st2 = heap.pop();
+      if (heap.top >= bestCost) break;
+      if (++steps2 > SEARCH.maxSteps) break;
+      const d = st2 & 3;
+      const p = st2 >> 2;
+      const i = p % nx;
+      const j = (p - i) / nx;
+      const cost = dist[st2];
+      if (heap.top > cost + W2 * (Math.abs(xs[i] - tx) + Math.abs(ys[j] - ty)) + 1e-6) continue;
+      if (i === ti && j === tj) {
+        const total = cost + (d === endDir ? 0 : COST.bend * (d === reverse[endDir] ? 3 : 1));
+        if (total < bestCost) {
+          bestCost = total;
+          best = st2;
+        }
+        continue;
+      }
+      for (let d2 = 0; d2 < 4; d2++) {
+        if (d2 === reverse[d]) continue;
+        const i2 = i + DX[d2];
+        const j2 = j + DY[d2];
+        if (i2 < 0 || j2 < 0 || i2 >= nx || j2 >= ny) continue;
+        const horizontal = d2 < 2;
+        const seg = horizontal ? j * nx + (i2 < i ? i2 : i) : (j2 < j ? j2 : j) * nx + i;
+        if (horizontal ? hBlock[seg] : vBlock[seg]) continue;
+        const len = horizontal ? Math.abs(xs[i2] - xs[i]) : Math.abs(ys[j2] - ys[j]);
+        let c = len * ((horizontal ? hugY[j] : hugX[i]) ? 1 + COST.hug : 1);
+        if (d2 !== d) c += COST.bend;
+        const used = horizontal ? hUse[seg] : vUse[seg];
+        if (used) c += used * COST.overlap * len;
+        const p2 = j2 * nx + i2;
+        if (horizontal ? vPass[p2] : hPass[p2]) c += COST.cross;
+        const st22 = p2 * 4 + d2;
+        const nd = cost + c;
+        if (seen[st22] !== stamp || nd < dist[st22]) {
+          seen[st22] = stamp;
+          dist[st22] = nd;
+          prev[st22] = st2;
+          heap.push(st22, nd + W2 * (Math.abs(xs[i2] - tx) + Math.abs(ys[j2] - ty)));
+        }
+      }
+    }
+    if (best < 0) return null;
+    const out = [];
+    for (let st2 = best; st2 >= 0; st2 = prev[st2]) {
+      const p = st2 >> 2;
+      out.push([p % nx, Math.floor(p / nx)]);
+    }
+    return out.reverse();
+  }
+  function mark(path6) {
+    for (let k = 1; k < path6.length; k++) {
+      const [i0, j0] = path6[k - 1];
+      const [i1, j1] = path6[k];
+      if (j0 === j1) {
+        hUse[j0 * nx + Math.min(i0, i1)]++;
+        hPass[j0 * nx + i0]++;
+        hPass[j1 * nx + i1]++;
+      } else {
+        vUse[Math.min(j0, j1) * nx + i0]++;
+        vPass[j0 * nx + i0]++;
+        vPass[j1 * nx + i1]++;
+      }
+    }
+  }
+}
+function towards(a, b, side) {
+  if (side === "right") return b.x > a.x;
+  if (side === "left") return b.x < a.x;
+  if (side === "bottom") return b.y > a.y;
+  return b.y < a.y;
+}
+function elbow(s, t, fromSide) {
+  if (fromSide === "left" || fromSide === "right") {
+    const mx = (s.x + t.x) / 2;
+    return [s, { x: mx, y: s.y }, { x: mx, y: t.y }, t];
+  }
+  const my = (s.y + t.y) / 2;
+  return [s, { x: s.x, y: my }, { x: t.x, y: my }, t];
+}
+function simplify(pts) {
+  const out = [];
+  for (const p of pts) {
+    const last = out[out.length - 1];
+    if (last && last.x === p.x && last.y === p.y) continue;
+    if (out.length >= 2) {
+      const a = out[out.length - 2];
+      if (a.x === last.x && last.x === p.x || a.y === last.y && last.y === p.y) out.pop();
+    }
+    out.push(p);
+  }
+  return out;
+}
+function narrowLabel(label, width) {
+  if (label.split(/[\s/\-_.:]+/).some((word) => textWidth(word, SIZES.edge) > width - 12)) return null;
+  if (textWidth(label, SIZES.edge) + 12 <= width) return null;
+  const lines = wrapText(label, SIZES.edge, width - 12, 2);
+  return { lines, width: Math.max(...lines.map((l) => textWidth(l, SIZES.edge))) + 12, height: 6 + lines.length * 13 };
+}
+var rectsOverlap = (a, b, pad = 0) => a.x0 < b.x1 + pad && b.x0 < a.x1 + pad && a.y0 < b.y1 + pad && b.y0 < a.y1 + pad;
+function placeLabels(edges, routes, geo) {
+  const { boxes } = geo;
+  const bounds = { x0: 2, y0: 2, x1: geo.width - 2, y1: geo.height - 2 };
+  const boxRects = [...boxes.values()].map((b) => ({ x0: b.x, y0: b.y, x1: b.x + b.width, y1: b.y + b.height }));
+  const solid = [...boxRects];
+  for (const lane of geo.lanes) {
+    if (!lane.headLine) continue;
+    const f = lane.frame;
+    solid.push({ x0: f.x + 8, y0: f.y + 4, x1: f.x + 20 + textWidth(lane.headLine, LANES.headSize + 1, true), y1: f.y + LANES.head - 2 });
+  }
+  for (const pts of routes.values()) {
+    if (pts.length < 2) continue;
+    const a = pts[pts.length - 2];
+    const b = pts[pts.length - 1];
+    const ux = Math.sign(b.x - a.x);
+    const uy = Math.sign(b.y - a.y);
+    const tail = { x: b.x - ux * 12, y: b.y - uy * 12 };
+    solid.push({ x0: Math.min(tail.x, b.x) - 6, y0: Math.min(tail.y, b.y) - 6, x1: Math.max(tail.x, b.x) + 6, y1: Math.max(tail.y, b.y) + 6 });
+  }
+  const gutters = geo.channels.filter((c) => c.axis === "x" && !c.fixed);
+  const inGutter = (x) => gutters.some((c) => x > c.lo && x < c.hi);
+  const placed = [];
+  const out = /* @__PURE__ */ new Map();
+  const area = (r, list) => list.reduce((sum, b) => sum + Math.max(0, Math.min(r.x1, b.x1) - Math.max(r.x0, b.x0)) * Math.max(0, Math.min(r.y1, b.y1) - Math.max(r.y0, b.y0)), 0);
+  for (const e of edges) {
+    const full = sizeEdgeLabel(e.label);
+    const pts = routes.get(e.id);
+    if (!full || !pts || pts.length < 2) continue;
+    const segs = [];
+    for (let k = 1; k < pts.length; k++) {
+      const a = pts[k - 1];
+      const b = pts[k];
+      const len = Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+      const vertical = a.x === b.x;
+      const score = len + (vertical ? 0 : 20) + (inGutter((a.x + b.x) / 2) ? 200 : 0);
+      segs.push({ a, b, vertical, score });
+    }
+    segs.sort((p, q2) => q2.score - p.score);
+    const sizesToTry = [full, ...[GUTTER_LABEL_W, 76].filter((w) => w < full.width).map((w) => narrowLabel(e.label, w)).filter(Boolean)];
+    let choice = null;
+    let best = null;
+    for (const lb of sizesToTry) {
+      for (const seg of segs) {
+        const offsets = seg.vertical ? [[0, 0], [lb.width / 2 - 5, 0], [-(lb.width / 2 - 5), 0]] : [[0, 0], [0, -(lb.height / 2 - 3)], [0, lb.height / 2 - 3]];
+        const len = Math.abs(seg.a.x - seg.b.x) + Math.abs(seg.a.y - seg.b.y);
+        const step = Math.min(0.5, Math.max(6 / Math.max(1, len), 1 / 40));
+        const ts = [0.5];
+        for (let d = step; d < 0.5; d += step) ts.push(0.5 - d, 0.5 + d);
+        for (const [dx, dy] of offsets) {
+          for (const t of ts) {
+            const cx = seg.a.x + (seg.b.x - seg.a.x) * t + dx;
+            const cy = seg.a.y + (seg.b.y - seg.a.y) * t + dy;
+            const r = { x0: cx - lb.width / 2, y0: cy - lb.height / 2, x1: cx + lb.width / 2, y1: cy + lb.height / 2 };
+            if (r.x0 < bounds.x0 || r.x1 > bounds.x1 || r.y0 < bounds.y0 || r.y1 > bounds.y1) continue;
+            const cost = area(r, boxRects) * 4 + area(r, solid) + area(r, placed) * 2;
+            if (!best || cost < best.cost) best = { cx, cy, r, lb, cost };
+            if (solid.some((q2) => rectsOverlap(r, q2, 3)) || placed.some((q2) => rectsOverlap(r, q2, 3))) continue;
+            choice = { cx, cy, r, lb };
+            break;
+          }
+          if (choice) break;
+        }
+        if (choice) break;
+      }
+      if (choice) break;
+    }
+    if (!choice) {
+      if (best) choice = best;
+      else {
+        const seg = segs[0];
+        const lb = sizesToTry[sizesToTry.length - 1];
+        const cx = Math.min(bounds.x1 - lb.width / 2, Math.max(bounds.x0 + lb.width / 2, (seg.a.x + seg.b.x) / 2));
+        const cy = Math.min(bounds.y1 - lb.height / 2, Math.max(bounds.y0 + lb.height / 2, (seg.a.y + seg.b.y) / 2));
+        choice = { cx, cy, lb, r: { x0: cx - lb.width / 2, y0: cy - lb.height / 2, x1: cx + lb.width / 2, y1: cy + lb.height / 2 } };
+      }
+    }
+    placed.push(choice.r);
+    out.set(e.id, { cx: choice.cx, cy: choice.cy, width: choice.lb.width, height: choice.lb.height, lines: choice.lb.lines });
+  }
+  return out;
+}
+function finish({ geo, routed }, model) {
+  const { boxes, lanes } = geo;
+  const nodes = model.nodes.filter((n) => boxes.has(n.id)).map((n) => ({ ...n, ...boxes.get(n.id) }));
+  const labels = placeLabels(model.edges, routed, geo);
+  const edges = model.edges.filter((e) => routed.has(e.id)).map((e) => ({ ...e, orthogonal: true, points: routed.get(e.id), labelBox: labels.get(e.id) || null }));
+  const groups = [];
+  for (const lane of lanes) {
+    if (!lane.group) continue;
+    const f = lane.frame;
+    groups.push({ ...lane.group, lane: true, labelLine: lane.headLine, x: f.x, y: f.y, width: f.w, height: f.h });
+  }
+  for (const g of model.groups) {
+    if (!g.parent) continue;
+    const ms = g.members.map((id) => boxes.get(id)).filter(Boolean);
+    if (!ms.length) continue;
+    const pad = 9;
+    const x0 = Math.min(...ms.map((b) => b.x)) - pad;
+    const y0 = Math.min(...ms.map((b) => b.y)) - pad - (g.label ? 6 : 0);
+    const x1 = Math.max(...ms.map((b) => b.x + b.width)) + pad;
+    const y1 = Math.max(...ms.map((b) => b.y + b.height)) + pad;
+    const labelLine = g.label ? wrapText(g.label, SIZES.group, Math.max(24, x1 - x0 - 24 - 14), 1)[0] : "";
+    groups.push({ ...g, labelLine, x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
+  }
+  let width = geo.width;
+  let height = geo.height;
+  for (const e of edges) {
+    for (const p of e.points) {
+      width = Math.max(width, Math.ceil(p.x + 8));
+      height = Math.max(height, Math.ceil(p.y + 8));
+    }
+    if (e.labelBox) {
+      width = Math.max(width, Math.ceil(e.labelBox.cx + e.labelBox.width / 2 + 6));
+      height = Math.max(height, Math.ceil(e.labelBox.cy + e.labelBox.height / 2 + 6));
+    }
+  }
+  return { rankdir: "lanes", nodes, edges, groups, width, height };
+}
+
+// src/runtime/components/_architecture-model.js
+var NODE_KINDS = ["frontend", "backend", "database", "messagebus", "cloud", "security", "external"];
+var EDGE_STYLES = ["solid", "dashed", "emphasis", "security"];
+var GROUP_KINDS = ["region", "security", "plain"];
+var DIRECTIONS = ["auto", "right", "down", "lanes"];
+var NODE_TONES = ["info", "success", "warning", "danger", "strong"];
+var EDGE_TONES = ["info", "success", "warning", "danger"];
+var SIZES = {
+  label: 13,
+  detail: 11,
+  tag: 10,
+  edge: 11,
+  group: 11,
+  nodeMinW: 128,
+  nodeMaxW: 232,
+  edgeMaxW: 176,
+  padX: 14,
+  icon: 15,
+  tagRow: 17
+};
+var DEFAULT_TARGET_WIDTH = 900;
+var LANES_TARGET_WIDTH = 1180;
+var LANES_SCROLL_WIDTH = 1e3;
+function textWidth(text, size, mono = false) {
+  let w = 0;
+  for (const ch of String(text ?? "")) w += charUnits(ch, mono);
+  return Math.ceil(w * size);
+}
+function charUnits(ch, mono) {
+  if (mono) return 0.62;
+  if (ch.charCodeAt(0) > 11903) return 1.02;
+  if (/[ilI.,:;'|!()[\]{} ]/.test(ch)) return 0.32;
+  if (/[mwMW@%&]/.test(ch)) return 0.88;
+  if (/[A-Z0-9#$?_~]/.test(ch)) return 0.68;
+  return 0.57;
+}
+function wrapText(text, size, maxWidth, maxLines = 2, mono = false) {
+  const words = (String(text ?? "").trim().match(/[^\s/\-_.:]*[\s/\-_.:]?/g) || []).filter(Boolean);
+  const lines = [];
+  let line = "";
+  const push = (s) => lines.push(s.trimEnd());
+  for (const word of words) {
+    if (lines.length > maxLines) break;
+    if (textWidth(line + word, size, mono) <= maxWidth) {
+      line += word;
+      continue;
+    }
+    if (line) push(line);
+    line = "";
+    let rest = word;
+    while (lines.length <= maxLines && textWidth(rest, size, mono) > maxWidth) {
+      let cut = 0;
+      let units = 0;
+      for (const ch of rest) {
+        const u = charUnits(ch, mono);
+        if (cut > 0 && Math.ceil((units + u) * size) > maxWidth) break;
+        units += u;
+        cut += ch.length;
+      }
+      push(rest.slice(0, cut));
+      rest = rest.slice(cut);
+    }
+    line = rest;
+  }
+  if (line) push(line);
+  if (lines.length <= maxLines) return lines.length ? lines : [""];
+  const kept = lines.slice(0, maxLines);
+  let last = Array.from(kept[maxLines - 1]);
+  while (last.length && textWidth(`${last.join("")}\u2026`, size, mono) > maxWidth) last.pop();
+  kept[maxLines - 1] = `${last.join("").trimEnd()}\u2026`;
+  return kept;
+}
+var isElement = (v) => v && typeof v === "object" && v.props && typeof v.props === "object";
+var str = (v) => typeof v === "string" ? v : v == null ? "" : String(v);
+function buildModel(props) {
+  const problems = [];
+  const nodes = /* @__PURE__ */ new Map();
+  const seenEls = /* @__PURE__ */ new Map();
+  let anon = 0;
+  const addNode = (el) => {
+    if (!isElement(el)) return null;
+    if (seenEls.has(el)) return seenEls.get(el);
+    const id = el.statementId || `_node${anon++}`;
+    if (!nodes.has(id)) {
+      const p = el.props;
+      const label = str(p.label).trim() || id;
+      nodes.set(id, {
+        id,
+        named: !!el.statementId,
+        label,
+        kind: NODE_KINDS.includes(p.kind) ? p.kind : "backend",
+        detail: str(p.detail).trim(),
+        tag: str(p.tag).trim(),
+        tone: NODE_TONES.includes(p.tone) ? p.tone : "",
+        row: Number.isInteger(p.row) && p.row > 0 ? Math.min(p.row, 200) : null
+      });
+    }
+    seenEls.set(el, id);
+    return id;
+  };
+  for (const el of Array.isArray(props?.nodes) ? props.nodes : []) addNode(el);
+  const edges = [];
+  const edgeIds = /* @__PURE__ */ new Set();
+  for (const el of Array.isArray(props?.edges) ? props.edges : []) {
+    if (!isElement(el)) continue;
+    const id = el.statementId || `_edge${anon++}`;
+    if (edgeIds.has(id)) continue;
+    const from = addNode(el.props.from);
+    const to = addNode(el.props.to);
+    if (!from || !to) continue;
+    edgeIds.add(id);
+    edges.push({
+      id,
+      named: !!el.statementId,
+      from,
+      to,
+      label: str(el.props.label).trim(),
+      style: EDGE_STYLES.includes(el.props.style) ? el.props.style : "solid",
+      tone: EDGE_TONES.includes(el.props.tone) ? el.props.tone : ""
+    });
+  }
+  const groups = [];
+  const groupIds = /* @__PURE__ */ new Set();
+  for (const el of Array.isArray(props?.groups) ? props.groups : []) {
+    if (!isElement(el)) continue;
+    const id = el.statementId || `_group${anon++}`;
+    if (groupIds.has(id)) continue;
+    const members2 = [...new Set((Array.isArray(el.props.members) ? el.props.members : []).map(addNode).filter(Boolean))];
+    if (!members2.length) continue;
+    groupIds.add(id);
+    groups.push({
+      id,
+      named: !!el.statementId,
+      label: str(el.props.label).trim(),
+      kind: GROUP_KINDS.includes(el.props.kind) ? el.props.kind : "region",
+      members: members2
+    });
+  }
+  nestGroups(groups, problems);
+  const direction = DIRECTIONS.includes(props?.direction) ? props.direction : "auto";
+  return { nodes: [...nodes.values()], edges, groups, direction, problems };
+}
+function nestGroups(groups, problems) {
+  const bySize = [...groups].sort((a, b) => a.members.length - b.members.length);
+  for (const g of bySize) {
+    const set2 = new Set(g.members);
+    g.parent = bySize.find((o) => o !== g && o.members.length >= g.members.length && bySize.indexOf(o) > bySize.indexOf(g) && g.members.every((m) => o.members.includes(m)))?.id ?? null;
+    g.memberSet = set2;
+  }
+  const owner = /* @__PURE__ */ new Map();
+  for (const g of bySize) {
+    for (const m of g.members) {
+      if (!owner.has(m)) owner.set(m, g.id);
+      else {
+        let first = groups.find((x) => x.id === owner.get(m));
+        if (!isAncestor(groups, g.id, first.id)) {
+          for (let up = groups.find((x) => x.id === first.parent); up; up = groups.find((x) => x.id === up.parent)) {
+            if (g.members.every((x) => up.memberSet.has(x))) break;
+            first = up;
+          }
+          problems.push(
+            `Groups ${first.named ? first.id : `"${first.label}"`} and ${g.named ? g.id : `"${g.label}"`} share ${m} but neither contains the other; it is drawn in the first. Nest one group inside the other or remove ${m} from one.`
+          );
+        }
+      }
+    }
+  }
+  for (const g of groups) g.directMembers = g.members.filter((m) => owner.get(m) === g.id);
+}
+function isAncestor(groups, ancestorId, id) {
+  let cur = groups.find((g) => g.id === id);
+  while (cur?.parent) {
+    if (cur.parent === ancestorId) return true;
+    cur = groups.find((g) => g.id === cur.parent);
+  }
+  return false;
+}
+function detailLinesFor(detail, width) {
+  if (!detail) return [];
+  const parts = detail.split("\n").map((t) => t.trim()).filter(Boolean);
+  const lines = [];
+  for (let i = 0; i < parts.length; i++) {
+    if (lines.length === 2) {
+      const last = lines.pop().replace(/…$/, "");
+      lines.push(wrapText(`${last} ${parts.slice(i).join(" ")}`, SIZES.detail, width, 1, true)[0]);
+      break;
+    }
+    lines.push(...wrapText(parts[i], SIZES.detail, width, 2 - lines.length, true));
+  }
+  return lines;
+}
+function sizeNode(node2, forceWidth = 0) {
+  const { label, detail, tag, nodeMinW, nodeMaxW, padX, icon } = SIZES;
+  const glyph = node2.tone === "danger" && !node2.tag ? 20 : 0;
+  const natural = Math.max(
+    textWidth(node2.label, label) + icon + 6 + glyph,
+    ...String(node2.detail || "").split("\n").map((t) => textWidth(t.trim(), detail, true)),
+    // With a tag, the risk glyph sits beside the chip in the tag row.
+    node2.tag ? textWidth(node2.tag, tag) + 14 + (node2.tone === "danger" ? 18 : 0) : 0
+  );
+  const width = forceWidth || Math.min(nodeMaxW, Math.max(nodeMinW, natural + padX * 2));
+  const labelLines = wrapText(node2.label, label, width - padX * 2 - icon - 6 - glyph, 2);
+  const detailLines = detailLinesFor(node2.detail, width - padX * 2);
+  const tagLine = node2.tag ? wrapText(node2.tag, tag, width - padX * 2 - 14, 1)[0] : "";
+  const tagRow = tagLine ? SIZES.tagRow : 0;
+  const height = 16 + tagRow + labelLines.length * 17 + detailLines.length * 15 + (detailLines.length ? 1 : 0) + 8;
+  return { width, height, labelLines, detailLines, tagLine, tagRow };
+}
+function sizeEdgeLabel(label) {
+  if (!label) return null;
+  const lines = wrapText(label, SIZES.edge, SIZES.edgeMaxW - 12, 2);
+  const width = Math.max(...lines.map((l) => textWidth(l, SIZES.edge))) + 12;
+  return { lines, width, height: 6 + lines.length * 13 };
+}
+function runLayout(model, rankdir) {
+  const g = new Uo.graphlib.Graph({ compound: true, multigraph: true });
+  g.setGraph({ rankdir, nodesep: rankdir === "LR" ? 26 : 34, ranksep: rankdir === "LR" ? 46 : 42, edgesep: 14, marginx: 18, marginy: 14 });
+  g.setDefaultEdgeLabel(() => ({}));
+  const boxes = /* @__PURE__ */ new Map();
+  for (const n of model.nodes) {
+    const box = sizeNode(n);
+    boxes.set(n.id, box);
+    g.setNode(n.id, { width: box.width, height: box.height });
+  }
+  for (const grp of model.groups) g.setNode(`group:${grp.id}`, {});
+  for (const grp of model.groups) {
+    if (grp.parent) g.setParent(`group:${grp.id}`, `group:${grp.parent}`);
+    for (const m of grp.directMembers) g.setParent(m, `group:${grp.id}`);
+  }
+  const labels = new Map(model.edges.map((e) => [e.id, sizeEdgeLabel(e.label)]));
+  for (const e of model.edges) {
+    const lb = labels.get(e.id);
+    g.setEdge(e.from, e.to, lb ? { width: lb.width, height: lb.height, labelpos: "c" } : {}, e.id);
+  }
+  Uo.layout(g);
+  const nodes = model.nodes.map((n) => {
+    const p = g.node(n.id);
+    const box = boxes.get(n.id);
+    return { ...n, ...box, x: p.x - box.width / 2, y: p.y - box.height / 2 };
+  });
+  const edges = model.edges.map((e) => {
+    const d = g.edge({ v: e.from, w: e.to, name: e.id }) || {};
+    const lb = labels.get(e.id);
+    return {
+      ...e,
+      points: (d.points || []).map((pt2) => ({ x: pt2.x, y: pt2.y })),
+      labelBox: lb ? { cx: d.x, cy: d.y, width: lb.width, height: lb.height, lines: lb.lines } : null
+    };
+  });
+  const groups = model.groups.map((grp) => {
+    const p = g.node(`group:${grp.id}`) || {};
+    const width2 = p.width ?? 0;
+    const labelLine = grp.label ? wrapText(grp.label, SIZES.group, Math.max(24, width2 - 24 - 14), 1)[0] : "";
+    return { ...grp, labelLine, x: (p.x ?? 0) - width2 / 2, y: (p.y ?? 0) - (p.height ?? 0) / 2, width: width2, height: p.height ?? 0 };
+  });
+  const gr2 = g.graph();
+  let width = Math.ceil(gr2.width || 0);
+  let height = Math.ceil(gr2.height || 0);
+  for (const e of edges) {
+    if (e.from !== e.to) continue;
+    const n = nodes.find((x) => x.id === e.from);
+    const d = g.edge({ v: e.from, w: e.to, name: e.id }) || {};
+    const r = n.x + n.width;
+    const b = n.y + n.height;
+    const cx = n.x + n.width / 2;
+    const cy = n.y + n.height / 2;
+    const placed = Number.isFinite(d.x) && Number.isFinite(d.y);
+    if (rankdir === "TB") {
+      const lx = placed ? d.x : r + 30 + (e.labelBox ? e.labelBox.width / 2 : 0);
+      const reach = Math.max(r + 18, e.labelBox ? lx - e.labelBox.width / 2 - 3 : lx);
+      const y1 = cy - n.height * 0.22;
+      const y2 = cy + n.height * 0.22;
+      e.points = [
+        { x: r, y: y1 },
+        { x: reach, y: y1 - 8 },
+        { x: reach, y: y2 + 8 },
+        { x: r, y: y2 }
+      ];
+      if (e.labelBox) e.labelBox = { ...e.labelBox, cx: Math.max(lx, reach + 3 + e.labelBox.width / 2), cy };
+    } else {
+      const ly = placed ? d.y : b + 30 + (e.labelBox ? e.labelBox.height / 2 : 0);
+      const reach = Math.max(b + 16, e.labelBox ? ly - e.labelBox.height / 2 - 3 : ly);
+      const spread = Math.min(30, n.width * 0.3);
+      e.points = [
+        { x: cx - spread, y: b },
+        { x: cx - spread - 8, y: reach },
+        { x: cx + spread + 8, y: reach },
+        { x: cx + spread, y: b }
+      ];
+      if (e.labelBox) e.labelBox = { ...e.labelBox, cx, cy: Math.max(ly, reach + 3 + e.labelBox.height / 2) };
+    }
+    const xs = e.points.map((p) => p.x);
+    const ys = e.points.map((p) => p.y);
+    if (e.labelBox) {
+      xs.push(e.labelBox.cx + e.labelBox.width / 2);
+      ys.push(e.labelBox.cy + e.labelBox.height / 2);
+    }
+    width = Math.max(width, Math.ceil(Math.max(...xs) + 12));
+    height = Math.max(height, Math.ceil(Math.max(...ys) + 10));
+  }
+  return { rankdir, nodes, edges, groups, width, height };
+}
+var LEGIBLE_SCALE = 0.85;
+function scaleAt(layout, targetWidth = DEFAULT_TARGET_WIDTH) {
+  return Math.min(1, targetWidth / Math.max(1, layout.width));
+}
+function layoutModel(model, targetWidth = DEFAULT_TARGET_WIDTH) {
+  if (!model.nodes.length) return null;
+  if (model.direction === "right") return runLayout(model, "LR");
+  if (model.direction === "down") return runLayout(model, "TB");
+  const planned = model.direction === "lanes" ? lanesPlanWidth(model) : 0;
+  if (planned) {
+    if (planned * LEGIBLE_SCALE <= targetWidth || targetWidth >= LANES_SCROLL_WIDTH) return runLanes(model);
+    return runStackedLanes(model, targetWidth);
+  }
+  const lr2 = runLayout(model, "LR");
+  if (scaleAt(lr2, targetWidth) >= LEGIBLE_SCALE) return lr2;
+  const tb = runLayout(model, "TB");
+  if (scaleAt(tb, targetWidth) >= LEGIBLE_SCALE) return tb;
+  return scaleAt(lr2, targetWidth) > scaleAt(tb, targetWidth) * 1.1 ? lr2 : tb;
+}
+function architectureNotes(props) {
+  const model = buildModel(props);
+  const notes = model.problems.map((message) => ({ code: "architecture", message }));
+  if (!model.nodes.length) return notes;
+  const layoutNote = (message) => notes.push({ code: "architecture-layout", message });
+  if (model.direction === "lanes") {
+    const lanes = runLanes(model);
+    if (!lanes) layoutNote('direction "lanes" needs Groups (each top-level Group is a column); without any it lays out as auto.');
+    else if (scaleAt(lanes, LANES_TARGET_WIDTH) < LEGIBLE_SCALE)
+      layoutNote(
+        `These lanes need about ${lanes.width}px; a laptop page gives about ${LANES_TARGET_WIDTH}px, so they scroll sideways there (narrow screens stack them as bands). To fit: fewer lanes, fewer boxes side by side, shorter edge labels.`
+      );
+  } else {
+    const l = layoutModel(model, DEFAULT_TARGET_WIDTH);
+    if (scaleAt(l, DEFAULT_TARGET_WIDTH) < LEGIBLE_SCALE) {
+      const forced = model.direction === "right" || model.direction === "down";
+      const auto = forced ? layoutModel({ ...model, direction: "auto" }, DEFAULT_TARGET_WIDTH) : l;
+      const advice = forced && scaleAt(auto, DEFAULT_TARGET_WIDTH) >= LEGIBLE_SCALE ? "Leave direction out (auto) to fit the page." : 'To fit: split it into smaller diagrams, or use direction "lanes" if it divides into owners or tiers.';
+      layoutNote(
+        `${forced ? `direction "${model.direction}" makes this` : "This diagram is"} about ${l.width}px wide, more than the page gives (about ${DEFAULT_TARGET_WIDTH}px), so it scrolls sideways. ${advice}`
+      );
+    }
+  }
+  return notes;
+}
+
 // src/cli/check.js
 var parser = null;
 var customParsers = /* @__PURE__ */ new WeakMap();
@@ -23776,6 +27039,19 @@ function statementLines(html) {
   for (const s of splitStatements(art.program)) out.set(s.id, { line: art.programLine + s.line - 1, text: s.text });
   return out;
 }
+function elementsOf(root, typeName) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [root];
+  while (stack.length) {
+    const v = stack.pop();
+    if (!v || typeof v !== "object" || seen.has(v)) continue;
+    seen.add(v);
+    if (v.typeName === typeName && v.props) out.push(v);
+    for (const child of Array.isArray(v) ? v : Object.values(v.props || {})) stack.push(child);
+  }
+  return out;
+}
 function checkHtml(html, { schema } = {}) {
   const art = readArtifact(html);
   const result = { ok: true, errors: [], warnings: [], statements: 0, title: art.title, hasMermaid: false };
@@ -23805,7 +27081,11 @@ function checkHtml(html, { schema } = {}) {
     return result;
   }
   result.statements = parsed.meta.statementCount;
+  const seen = /* @__PURE__ */ new Set();
   for (const e of parsed.meta.errors) {
+    const key = `${e.severity}\0${e.code}\0${e.statementId}\0${e.message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
     const entry = {
       code: e.code,
       statement: e.statementId,
@@ -23837,6 +27117,17 @@ function checkHtml(html, { schema } = {}) {
   if (parsed.meta.incomplete) {
     result.errors.push({ code: "incomplete", message: "The program ends mid-statement (an unclosed string or bracket)." });
   }
+  const diagrams = /* @__PURE__ */ new Set();
+  for (const el of elementsOf(parsed.root, "Architecture")) {
+    if (el.statementId && diagrams.has(el.statementId)) continue;
+    diagrams.add(el.statementId);
+    try {
+      for (const note of architectureNotes(el.props)) {
+        result.warnings.push({ code: note.code, statement: el.statementId, line: lineOf(el.statementId), message: note.message });
+      }
+    } catch {
+    }
+  }
   const dupes = /* @__PURE__ */ new Map();
   for (const s of splitStatements(art.program)) dupes.set(s.id, (dupes.get(s.id) || 0) + 1);
   for (const [id, n] of dupes) {
@@ -24091,7 +27382,9 @@ FEEDBACK (what poll returns)
 
 CHECK verifies syntax, component names, required props, unresolved references and
 statements unreachable from root. Mermaid syntax is only checked when it renders; failures
-show in the reviewer's panel and can come back as render_error.
+show in the reviewer's panel and can come back as render_error. CHECK does not judge how
+a page looks: open it for that. It does warn when an Architecture diagram will not fit the
+page (it would scroll sideways).
 
 WHEN TO USE
   Plans, comparisons, decisions, reviews, reports: anything easier to grasp as a page.
@@ -24238,33 +27531,33 @@ function describeItems(abs, items) {
     lines = statementLines(fs8.readFileSync(abs, "utf8"));
   } catch {
   }
-  const at = (id) => {
+  const at2 = (id) => {
     const l = lines.get(id);
     if (!l) return {};
     const first = l.text.split("\n")[0];
     return { line: l.line, source: first.length > 110 ? first.slice(0, 109) + "\u2026" : first };
   };
-  return items.map((it) => {
-    if (it.kind === "annotation") {
-      const o = { annotation: `${it.target} (${it.component})`, ...at(it.target) };
-      const within = (it.path || []).slice(0, -1).filter((p) => p !== "root");
+  return items.map((it2) => {
+    if (it2.kind === "annotation") {
+      const o = { annotation: `${it2.target} (${it2.component})`, ...at2(it2.target) };
+      const within = (it2.path || []).slice(0, -1).filter((p) => p !== "root");
       if (within.length) o.within = within.join(" > ");
-      if (it.selection) o.selection = it.selection;
-      else if (it.excerpt) o.excerpt = it.excerpt;
-      if (it.detail) o.detail = it.detail;
-      o.note = it.note || "(no note: the selection itself is the point)";
+      if (it2.selection) o.selection = it2.selection;
+      else if (it2.excerpt) o.excerpt = it2.excerpt;
+      if (it2.detail) o.detail = it2.detail;
+      o.note = it2.note || "(no note: the selection itself is the point)";
       return o;
     }
-    if (it.kind === "action") {
-      const o = { action: it.message };
-      if (it.form) o.form = it.form;
-      if (it.context !== void 0) o.context = it.context;
+    if (it2.kind === "action") {
+      const o = { action: it2.message };
+      if (it2.form) o.form = it2.form;
+      if (it2.context !== void 0) o.context = it2.context;
       return o;
     }
-    if (it.kind === "render-error") {
-      return { render_error: it.statement || "(page)", ...at(it.statement), error: it.message, note: it.note };
+    if (it2.kind === "render-error") {
+      return { render_error: it2.statement || "(page)", ...at2(it2.statement), error: it2.message, note: it2.note };
     }
-    return { message: it.text ?? it.note ?? "" };
+    return { message: it2.text ?? it2.note ?? "" };
   });
 }
 var NEXT = {
@@ -24456,3 +27749,8 @@ main().catch((err) => {
   process.stdout.write(format({ status: "error", error: String(err?.message || err) }) + "\n");
   process.exitCode = 1;
 });
+/*! Bundled license information:
+
+@dagrejs/dagre/dist/dagre.esm.js:
+  (*! For license information please see dagre.esm.js.LEGAL.txt *)
+*/