@graphty/graphty-element 2.5.1 → 2.6.0

package/dist/chunks/optionsFromZod-CKMYSwTz.js

@@ -0,0 +1,3636 @@
+import { c as yt, G as g, S as Zt } from "./pluginRegistry-Bs8bEkz9.js";
+import { K as Xt, f as Qt } from "./types-DFchv4Ny.js";
+import { b as en } from "./GraphtyLogger-B_O67a6c.js";
+import { Graph as tn, accelerated as Je } from "@graphty/algorithms";
+import { INVALID_INDEX as E, maskTest as oe, makeMask as he } from "@graphty/graph-format";
+import { z as bt } from "zod/v4";
+const ie = yt({
+  kind: "camera",
+  idOf: (e) => e.descriptor.id,
+  descriptorOf: (e) => e.descriptor,
+  implementationOf: (e) => e.compute,
+  builtInIds: () => Xt
+});
+function ks(e, t) {
+  const n = e.descriptor;
+  if (n === void 0 || typeof n != "object")
+    throw new g({
+      code: "E_BAD_COMMAND",
+      message: "registerCameraView takes a camera view with a descriptor",
+      source: "registry",
+      details: { kind: "camera", field: "descriptor" }
+    });
+  if (!Array.isArray(n.modes) || n.modes.length === 0)
+    throw new g({
+      code: "E_BAD_COMMAND",
+      message: `the camera view "${String(n.id)}" declares no drawing modes, so nothing could ever offer it: a view says where it works with \`modes\`, and the element refuses the rest`,
+      source: "registry",
+      details: { kind: "camera", name: String(n.id), field: "modes" }
+    });
+  if (!Array.isArray(n.options))
+    throw new g({
+      code: "E_BAD_COMMAND",
+      message: `the camera view "${String(n.id)}" declares no options list. A view that takes no configuration declares an empty one, so a form has something to render and the element has something to check a caller's values against`,
+      source: "registry",
+      details: { kind: "camera", name: String(n.id), field: "options" }
+    });
+  if (typeof e.compute != "function")
+    throw new g({
+      code: "E_BAD_COMMAND",
+      message: `the camera view "${String(n.id)}" was registered without a compute function`,
+      source: "registry",
+      details: { kind: "camera", name: String(n.id), field: "compute" }
+    });
+  ie.register(e, t);
+}
+function As() {
+  return ie.descriptors();
+}
+function Ss(e) {
+  return ie.byId(e);
+}
+function Ns() {
+  ie.clearForTesting();
+}
+const nn = ["forceAtlas2", "fruchtermanReingold", "springElectrical", "release"], rn = [
+  "pageRank",
+  "sssp",
+  "breadthFirstSearch",
+  "connectedComponents",
+  "weaklyConnectedComponents",
+  "minimumSpanningTree"
+];
+function Es(e) {
+  const t = {
+    kind: e.backend
+  };
+  for (const n of nn) {
+    const r = e[n];
+    typeof r == "function" && (t[n] = r.bind(e));
+  }
+  return t;
+}
+function sn(e) {
+  const t = {
+    kind: e.backend
+  };
+  for (const n of rn) {
+    const r = e[n];
+    typeof r == "function" && (t[n] = r.bind(e));
+  }
+  return t;
+}
+const on = ["auto", "off", "required"], Is = "auto";
+function Rs(e) {
+  return typeof e == "string" && on.includes(e);
+}
+const an = "f64", Ms = "f32", $s = "acceleration.minNodes", Cs = 0, _s = "RTX 4070 SUPER, headless Chromium, 2026-09-27", Ts = Object.freeze(
+  {
+    // Above the 50,000-node render ceiling, so not routed to the device today; the kernel's own
+    // resident crossover, because the element cannot hold a graph this large to measure one.
+    breadthFirstSearch: 141e3,
+    // Likewise above the render ceiling, and likewise the kernel's resident crossover.
+    sssp: 107e3,
+    // Measured through the element: the only capability that crosses inside what it can hold.
+    pageRank: 5e4,
+    // Above the render ceiling. Was 50,000, where the device measured 0.51x -- twice as slow.
+    connectedComponents: 132e3
+  }
+), ae = yt({
+  kind: "algorithm",
+  idOf: (e) => e.descriptor.key,
+  descriptorOf: (e) => e.descriptor,
+  implementationOf: (e) => e.descriptor,
+  builtInIds: () => Qt
+});
+function cn(e, t) {
+  if (e.descriptor.key !== e.type)
+    throw new g({
+      code: "E_BAD_COMMAND",
+      message: `the algorithm registered as "${e.namespace}:${e.type}" publishes the catalogue key "${e.descriptor.key}". An algorithm has one name: make "descriptor.key" equal "static type".`,
+      source: "registry",
+      details: {
+        kind: "algorithm",
+        field: "descriptor.key",
+        key: e.descriptor.key,
+        type: e.type,
+        namespace: e.namespace
+      }
+    });
+  if (e.descriptor.fields.find((r) => r.name === "runs") !== void 0)
+    throw new g({
+      code: "E_BAD_COMMAND",
+      message: `the algorithm "${e.namespace}:${e.type}" publishes a field named "runs", which is reserved. Name the field something else.`,
+      source: "registry",
+      details: { kind: "algorithm", field: "descriptor.fields", name: "runs", reason: "reserved-field" }
+    });
+  ae.register(e, t);
+}
+function Fs() {
+  return ae.descriptors();
+}
+function xs(e) {
+  return ae.byId(e);
+}
+function zs() {
+  ae.clearForTesting();
+}
+const un = {
+  fixed: ["kind", "nodes", "edges", "reading"],
+  rule: ["kind", "where", "reading"],
+  path: ["kind", "nodes", "edges", "directed"]
+}, wt = ["source", "target", "id", "key", "ordinal", "among"];
+function S(e) {
+  const t = {};
+  for (const n of Object.keys(e).sort())
+    e[n] !== void 0 && (t[n] = e[n]);
+  return t;
+}
+function R(e) {
+  return e === 0 ? 0 : e;
+}
+function vt(e, t) {
+  return e === t ? 0 : e < t ? -1 : 1;
+}
+function z(e, t) {
+  return typeof e == "number" ? typeof t == "number" ? e - t : -1 : typeof t == "number" ? 1 : vt(String(e), String(t));
+}
+function Ot(e, t) {
+  for (const n of wt) {
+    const r = e[n], s = t[n];
+    if (r === void 0 || s === void 0) {
+      if (r !== s)
+        return r === void 0 ? -1 : 1;
+      continue;
+    }
+    const o = z(r, s);
+    if (o !== 0)
+      return o;
+  }
+  return vt(JSON.stringify(e), JSON.stringify(t));
+}
+function U(e, t) {
+  const n = [...e].sort(t);
+  return n.filter((r, s) => s === 0 || t(n[s - 1], r) !== 0);
+}
+function Ls(e) {
+  return U(e, (t, n) => Ot(t, n));
+}
+function js(e) {
+  return U(e.map(R), z);
+}
+function _e(e) {
+  const t = e, n = { ...t };
+  for (const r of wt)
+    n[r] = R(t[r]);
+  return S(n);
+}
+function kt(e) {
+  return U(
+    e.map(_e),
+    (t, n) => Ot(t, n)
+  );
+}
+function dn(e) {
+  return e === void 0 || e.length === 0 ? void 0 : kt(e);
+}
+function ln(e) {
+  if (e === null)
+    return null;
+  if (!Array.isArray(e))
+    return _e(e);
+  const t = kt(e);
+  return t.length === 1 ? t[0] : t;
+}
+const fn = /* @__PURE__ */ new Set([
+  "expression",
+  "edges",
+  "range",
+  "categories",
+  "degree",
+  "component",
+  "neighborhood",
+  "threshold"
+]);
+function pn(e) {
+  if (typeof e != "object" || e === null)
+    return e;
+  const t = e;
+  return typeof t.runId == "string" ? t.runId : typeof t.id == "string" ? t.id : e;
+}
+function hn(e) {
+  if (typeof e != "object" || e === null || Array.isArray(e))
+    return e;
+  const t = e, { key: n } = t, r = typeof n == "object" && n !== null && !Array.isArray(n) ? S({ ...n, value: R(n.value) }) : n;
+  return S({ ...t, result: pn(t.result), key: r });
+}
+function ge(e) {
+  if (typeof e != "object" || e === null || Array.isArray(e))
+    return e;
+  const t = e, { kind: n } = t;
+  if (n === "all" || n === "any")
+    return S({ ...t, of: Array.isArray(t.of) ? t.of.map(ge) : t.of });
+  if (n === "not")
+    return S({ ...t, of: ge(t.of) });
+  if (n === "member")
+    return S({ ...t, of: gn(t.of) });
+  if (n === "item")
+    return S({ ...t, item: hn(t.item) });
+  if (typeof n == "string" && fn.has(n)) {
+    const r = {};
+    for (const [s, o] of Object.entries(t))
+      r[s] = s === "seeds" && Array.isArray(o) ? o.map(R) : R(o);
+    return S(r);
+  }
+  return e;
+}
+function gn(e) {
+  if (typeof e != "object" || e === null || Array.isArray(e))
+    return e;
+  const t = e;
+  return q(t, ["define"]) && q(t, ["nodes"]) ? e : typeof t.define == "object" && t.define !== null ? { define: At(t.define) } : Array.isArray(t.nodes) ? { nodes: U(t.nodes.map(R), z) } : e;
+}
+function q(e, t) {
+  return Object.keys(e).some((n) => e[n] !== void 0 && !t.includes(n));
+}
+function At(e) {
+  const t = e;
+  switch (e.kind) {
+    case "fixed": {
+      const n = q(t, un.fixed), { reading: r, edges: s } = e, o = e.nodes.map(R);
+      return S({
+        ...t,
+        nodes: n ? o : U(o, z),
+        edges: n ? s?.map(_e) : dn(s),
+        reading: r === "clipped" ? "listed" : r
+      });
+    }
+    case "rule": {
+      const n = ge(e.where), r = typeof n == "object" && n.kind === "expression" && !q(n, ["kind", "where"]) ? n.where : n;
+      return S({ ...t, where: r });
+    }
+    case "path": {
+      const n = e.edges?.map(ln);
+      return S({
+        ...t,
+        nodes: e.nodes.map(R),
+        edges: n === void 0 || n.length === 0 ? void 0 : n,
+        directed: e.directed === !1 ? void 0 : e.directed
+      });
+    }
+    default:
+      return e;
+  }
+}
+const me = { a: 0, b: 0 }, Te = 2166136261, K = 16777619, Fe = 461845907, Z = 2246822507, ye = 35, mn = 36, St = 105, yn = 107, Nt = 111, X = new DataView(new ArrayBuffer(8)), Et = new Float64Array(X.buffer), It = new Uint32Array(X.buffer), D = new Float64Array(4), Rt = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
+let F = Te, x = Fe;
+function M() {
+  F = Te, x = Fe;
+}
+function I(e) {
+  F = Math.imul(F ^ e, K) >>> 0, x = Math.imul(x ^ e, Z) >>> 0;
+}
+function b(e) {
+  if (I(ye), !Rt) {
+    X.setFloat64(0, e === 0 ? 0 : e, !0);
+    for (let r = 0; r < 8; r++)
+      I(X.getUint8(r));
+    return;
+  }
+  Et[0] = e === 0 ? 0 : e;
+  let t = F, n = x;
+  for (let r = 0; r < 2; r++) {
+    const s = It[r];
+    for (let o = 0; o < 32; o += 8) {
+      const i = s >>> o & 255;
+      t = Math.imul(t ^ i, K) >>> 0, n = Math.imul(n ^ i, Z) >>> 0;
+    }
+  }
+  F = t, x = n;
+}
+function xe(e) {
+  I(mn);
+  for (let t = 0; t < e.length; t++)
+    I(e.charCodeAt(t));
+}
+function Q(e) {
+  typeof e == "number" ? b(e) : xe(e);
+}
+function ee(e) {
+  let t = e ^ e >>> 16;
+  return t = Math.imul(t, 2246822507), t ^= t >>> 13, t = Math.imul(t, 3266489909), (t ^ t >>> 16) >>> 0;
+}
+function $() {
+  return { a: ee(F), b: ee(x) };
+}
+function be(e) {
+  return M(), Q(e), $();
+}
+function te(e, t) {
+  if (!Rt)
+    return M(), b(e.a), b(e.b), b(t.a), b(t.b), $();
+  let n = Te, r = Fe;
+  D[0] = e.a, D[1] = e.b, D[2] = t.a, D[3] = t.b;
+  for (let s = 0; s < 4; s++) {
+    Et[0] = D[s], n = Math.imul(n ^ ye, K) >>> 0, r = Math.imul(r ^ ye, Z) >>> 0;
+    for (let o = 0; o < 2; o++) {
+      const i = It[o];
+      for (let a = 0; a < 32; a += 8) {
+        const c = i >>> a & 255;
+        n = Math.imul(n ^ c, K) >>> 0, r = Math.imul(r ^ c, Z) >>> 0;
+      }
+    }
+  }
+  return { a: ee(n), b: ee(r) };
+}
+function bn(e) {
+  if (M(), e.id !== void 0)
+    I(St), Q(e.id);
+  else if (e.key !== void 0)
+    I(yn), Q(e.key);
+  else if (e.ordinal !== void 0 && e.among !== void 0)
+    I(Nt), b(e.ordinal), b(e.among);
+  else
+    throw new Error("an edge member needs an id, a key, or an ordinal with among");
+  return $();
+}
+function ze(e) {
+  return be(e);
+}
+function Mt(e, t) {
+  const n = be(e.source), r = be(e.target), s = t ? te(n, r) : we(n, r);
+  return te(s, bn(e));
+}
+function wn(e, t, n, r, s, o) {
+  const i = n ? te(e, t) : { a: e.a + t.a >>> 0, b: e.b + t.b >>> 0 };
+  let a;
+  return r !== void 0 ? (M(), I(St), Q(r), a = $()) : ((s !== We || o !== Ye) && (M(), I(Nt), b(s), b(o), We = s, Ye = o, qe = $()), a = qe), te(i, a);
+}
+let We = -1, Ye = -1, qe = me;
+function we(e, t) {
+  return { a: e.a + t.a >>> 0, b: e.b + t.b >>> 0 };
+}
+function Ds(e, t) {
+  return { a: e.a - t.a >>> 0, b: e.b - t.b >>> 0 };
+}
+function ce(e) {
+  return e.a.toString(16).padStart(8, "0") + e.b.toString(16).padStart(8, "0");
+}
+function ne(e, t) {
+  return { count: e, sum: ce(t) };
+}
+function Ps(e, t, n) {
+  const r = {
+    ...n === void 0 || n.count === 0 ? {} : { edges: ne(n.count, n.sum) },
+    kind: "fixed",
+    nodes: ne(t.count, t.sum),
+    reading: e
+  };
+  return M(), xe(JSON.stringify(r)), `r1:${ce($())}`;
+}
+function Hs(e) {
+  const t = At(e);
+  let n = t;
+  if (t.kind === "fixed") {
+    let r = me;
+    for (const o of t.nodes)
+      r = we(r, ze(o));
+    const s = { ...t, nodes: ne(t.nodes.length, r) };
+    if (t.edges !== void 0) {
+      let o = me;
+      for (const i of t.edges)
+        o = we(o, Mt(i, !0));
+      s.edges = ne(t.edges.length, o);
+    }
+    n = s;
+  }
+  return M(), xe(JSON.stringify(n)), `r1:${ce($())}`;
+}
+function Us(e, t) {
+  return M(), b(e.count), b(e.sum.a), b(e.sum.b), b(t.count), b(t.sum.a), b(t.sum.b), `d1:${ce($())}`;
+}
+function vn(e) {
+  return String(e);
+}
+function On(e) {
+  if (!/^\d+$/.test(e))
+    return E;
+  const t = Number(e);
+  return Number.isSafeInteger(t) ? t : E;
+}
+function kn(e, t) {
+  const n = On(t);
+  return n === E ? E : e.edgeIndexOf(n);
+}
+function Gs() {
+  return { next: 0 };
+}
+function $t(e) {
+  return `graphty:e${e}`;
+}
+function Bs(e, t, n) {
+  switch (e) {
+    case "keep":
+      return { kind: "add" };
+    case "error":
+      return { kind: "refuse" };
+    case "first":
+      return { kind: "drop" };
+    case "sum":
+      return { kind: "merge", weight: t + n, replaceRecord: !1 };
+    case "min":
+      return { kind: "merge", weight: Math.min(t, n), replaceRecord: !1 };
+    case "max":
+      return { kind: "merge", weight: Math.max(t, n), replaceRecord: !1 };
+    default:
+      return { kind: "merge", weight: n, replaceRecord: !0 };
+  }
+}
+const ve = "graphty.edgeId", B = {
+  /** Node: `hashNodeId` of the node id, two uint32 lanes. */
+  nodeHash: "graphty.nodeHash",
+  /** Edge: `hashEdgeMember` of the edge's stable identity, two uint32 lanes. */
+  edgeHash: "graphty.edgeHash",
+  /** Edge: its position among its pair's surviving edges in its load; -1 for a session edge. */
+  edgeOrdinal: "graphty.edgeOrdinal",
+  /** Edge: its pair's surviving edge count in its load; -1 for a session edge. */
+  edgeAmong: "graphty.edgeAmong"
+}, An = "graphty.edgePairsOrdered";
+function Sn(e, t, n, r, s) {
+  const o = e.length, i = new Uint32Array(o), a = new Uint32Array(o);
+  let c = 0;
+  for (let h = 0; h < o; h++) {
+    const [A, L] = t.endpoints(e[h]), j = !n && L < A;
+    i[h] = j ? L : A, a[h] = j ? A : L, c = Math.max(c, i[h] + 1, a[h] + 1);
+  }
+  const { perm: u, bytes: f } = Nn(i, a, c);
+  e.byteLength + i.byteLength + a.byteLength + f;
+  const l = t.hashOf === void 0 ? (h) => ze(t.idOf(h)) : t.hashOf.bind(t);
+  let d = 0, p = -1, w = { a: 0, b: 0 };
+  for (; d < o; ) {
+    const h = u[d];
+    let A = d + 1;
+    for (; A < o && i[u[A]] === i[h] && a[u[A]] === a[h]; )
+      A++;
+    i[h] !== p && (p = i[h], w = l(p));
+    const L = l(a[h]), j = A - d;
+    for (let G = d; G < A; G++) {
+      const Be = u[G], Ve = G - d;
+      s(
+        e[Be],
+        Ve,
+        j,
+        wn(w, L, n, r(Be), Ve, j)
+      );
+    }
+    d = A;
+  }
+}
+function Nn(e, t, n) {
+  const r = e.length;
+  if (n > 4 * r) {
+    const c = new Uint32Array(r);
+    for (let u = 0; u < r; u++)
+      c[u] = u;
+    return c.sort((u, f) => e[u] - e[f] || t[u] - t[f] || u - f), { perm: c, bytes: c.byteLength };
+  }
+  const s = new Uint32Array(n + 1), o = new Uint32Array(r), i = new Uint32Array(r), a = (c, u, f) => {
+    s.fill(0);
+    for (let l = 0; l < r; l++)
+      s[c[l] + 1]++;
+    for (let l = 0; l < n; l++)
+      s[l + 1] += s[l];
+    for (let l = 0; l < r; l++) {
+      const d = u === null ? l : u[l];
+      f[s[c[d]]++] = d;
+    }
+  };
+  return a(t, null, o), a(e, o, i), { perm: i, bytes: s.byteLength + o.byteLength + i.byteLength };
+}
+function Vs(e, t, n, r, s) {
+  const [o, i] = e.endpoints(t);
+  return Mt(
+    { source: e.idOf(o), target: e.idOf(i), id: r ?? $t(n) },
+    s
+  );
+}
+function Ct(e) {
+  const t = e.graph.typed(An, "u8");
+  return t === null ? e.directed : t.data[0] === 1;
+}
+function Js(e, t) {
+  if (t || typeof e != "object" || e === null)
+    return e;
+  const { source: n, target: r } = e, s = (o) => typeof o == "string" || typeof o == "number";
+  return !s(n) || !s(r) || z(r, n) >= 0 ? e : { ...e, source: r, target: n };
+}
+function En(e) {
+  return {
+    endpoints: (t) => [e.edgeSource(t), e.edgeTarget(t)],
+    idOf: (t) => e.ids.idOf(t)
+  };
+}
+const Ke = /* @__PURE__ */ new WeakMap();
+function In(e) {
+  const t = e.nodes.typed(B.nodeHash, "u32"), n = e.edges.typed(B.edgeHash, "u32"), r = e.edges.typed(B.edgeOrdinal, "i32"), s = e.edges.typed(B.edgeAmong, "i32");
+  if (t !== null && n !== null && r !== null && s !== null)
+    return {
+      nodeHash: t.data,
+      edgeHash: n.data,
+      edgeOrdinal: r.data,
+      edgeAmong: s.data
+    };
+  let o = Ke.get(e);
+  return o === void 0 && (o = Rn(e), Ke.set(e, o)), o;
+}
+function Rn(e) {
+  const t = new Uint32Array(2 * e.nodeCount);
+  for (let i = 0; i < e.nodeCount; i++) {
+    const { a, b: c } = ze(e.ids.idOf(i));
+    t[2 * i] = a, t[2 * i + 1] = c;
+  }
+  const n = new Uint32Array(2 * e.edgeCount), r = new Int32Array(e.edgeCount), s = new Int32Array(e.edgeCount), o = new Uint32Array(e.edgeCount);
+  for (let i = 0; i < o.length; i++)
+    o[i] = i;
+  return Sn(
+    o,
+    En(e),
+    Ct(e),
+    () => {
+    },
+    (i, a, c, u) => {
+      r[i] = a, s[i] = c, n[2 * i] = u.a, n[2 * i + 1] = u.b;
+    }
+  ), { nodeHash: t, edgeHash: n, edgeOrdinal: r, edgeAmong: s };
+}
+function Ws(e, t, n) {
+  let r = e.ids.idOf(e.edgeSource(t)), s = e.ids.idOf(e.edgeTarget(t));
+  if (!Ct(e) && z(s, r) < 0 && ([r, s] = [s, r]), n !== void 0)
+    return { source: r, target: s, id: n };
+  const { edgeOrdinal: o, edgeAmong: i } = In(e), a = o[t];
+  if (a >= 0)
+    return { source: r, target: s, ordinal: a, among: i[t] };
+  const c = e.edges.typed(ve, "u32");
+  if (c === null || !c.isSet(t))
+    throw new Error(`edge ${t} has neither an ordinal nor a counter to mint an id from`);
+  return { source: r, target: s, id: $t(c.data[t]) };
+}
+const Mn = 256 * 1024 * 1024, $n = 1.5, Ze = /* @__PURE__ */ new WeakMap();
+let Cn = 1;
+function _n(e) {
+  if (e === null)
+    return 0;
+  let t = Ze.get(e);
+  return t === void 0 && (t = Cn++, Ze.set(e, t)), t;
+}
+function Tn(e, t) {
+  let n = 2166136261, r = 16777619 ^ e.length;
+  for (const s of [e, t]) {
+    for (let o = 0; o < s.length; o++) {
+      const i = s[o];
+      n = Math.imul(n ^ i, 16777619), r = Math.imul(r ^ (i >>> 16 | i << 16), 16777619) ^ o;
+    }
+    n = Math.imul(n ^ s.length, 16777619);
+  }
+  return `${(n >>> 0).toString(16)}${(r >>> 0).toString(16)}`;
+}
+function Xe(e, t) {
+  if (e === t)
+    return !0;
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t[n])
+      return !1;
+  return !0;
+}
+function Qe(e) {
+  const t = /* @__PURE__ */ new Set(), n = [...e];
+  let r = 0;
+  for (; n.length > 0; ) {
+    const s = n.pop();
+    if (!(s === null || typeof s != "object" || t.has(s))) {
+      if (t.add(s), ArrayBuffer.isView(s)) {
+        r += s.byteLength;
+        continue;
+      }
+      if (!(s instanceof ArrayBuffer)) {
+        if (s instanceof Map)
+          for (const [o, i] of s)
+            n.push(o, i);
+        else if (s instanceof Set)
+          for (const o of s)
+            n.push(o);
+        for (const o of Reflect.ownKeys(s)) {
+          const i = Object.getOwnPropertyDescriptor(s, o);
+          i !== void 0 && "value" in i && n.push(i.value);
+        }
+      }
+    }
+  }
+  return r;
+}
+function et(e) {
+  return e.byteLength({ columns: !0, ids: !0 });
+}
+class Fn {
+  /**
+   * An empty cache.
+   * @param options - The release hook and, for tests, the byte bound.
+   * @param options.release - Frees an accelerator's device buffers for a snapshot nothing uses.
+   * @param options.limit - A fixed byte bound instead of max(256 MB, 1.5 x the full snapshot).
+   */
+  constructor(t = {}) {
+    this.options = t, this.entries = /* @__PURE__ */ new Map(), this.draining = /* @__PURE__ */ new Set(), this.reservations = /* @__PURE__ */ new Map(), this.waiters = [], this.fullBytes = 0, this.disposed = !1;
+  }
+  /**
+   * The byte bound now.
+   * @returns The bound.
+   */
+  get bound() {
+    return this.options.limit ?? Math.max(Mn, Math.ceil($n * this.fullBytes));
+  }
+  /**
+   * The bytes the live entries hold, draining ones included.
+   * @returns The byte count.
+   */
+  get bytes() {
+    return Qe([...this.live()].map(nt));
+  }
+  /**
+   * Every live entry, draining ones included, least recently used first. For the accounting test.
+   * @returns The entries.
+   */
+  list() {
+    return [...this.live()].map((t) => ({
+      key: t.key,
+      snapshot: t.snapshot,
+      edgeRemap: t.edgeRemap,
+      nodeOrigin: t.nodeOrigin,
+      nodes: t.nodes,
+      edges: t.edges,
+      held: t.holders.size > 0,
+      marked: t.marked
+    }));
+  }
+  /**
+   * A cached input, held for a run on a hit.
+   * @param holder - The run.
+   * @param membership - What it is derived for.
+   * @param orientation - The orientation.
+   * @param simplify - The merge policy.
+   * @returns The input, or undefined on a miss.
+   */
+  get(t, n, r, s) {
+    this.sync(n);
+    const o = tt(n, r, s), i = this.entries.get(o);
+    if (!(i === void 0 || !Xe(i.nodes, n.nodes) || !Xe(i.edges, n.edges)))
+      return this.entries.delete(o), this.entries.set(o, i), i.holders.add(t), i;
+  }
+  /**
+   * Cache an input a run derived, held for it, then evict unheld entries past the bound.
+   * @param holder - The run.
+   * @param membership - What it was derived for.
+   * @param orientation - The orientation.
+   * @param simplify - The merge policy.
+   * @param input - The derived input.
+   * @param full - The full snapshot it was derived from, whose bytes set the bound.
+   * @returns The input.
+   */
+  put(t, n, r, s, o, i) {
+    this.sync(n), this.fullBytes = et(i);
+    const a = tt(n, r, s), c = this.entries.get(a);
+    c !== void 0 && (this.entries.delete(a), this.evictEntry(c));
+    const u = {
+      ...o,
+      key: a,
+      serial: n.serial,
+      store: n.store,
+      nodes: n.nodes,
+      edges: n.edges,
+      holders: /* @__PURE__ */ new Set([t]),
+      marked: this.disposed
+    };
+    return this.disposed ? this.draining.add(u) : (this.entries.set(a, u), this.shrink()), u;
+  }
+  /**
+   * Reserve room for a run's derivation before it starts. Evicts unheld entries to make room;
+   * waits while a DIFFERENT run holds or reserves what would free it; refuses `E_TOO_LARGE`
+   * when nothing else holds anything and it still does not fit. A run that already holds an
+   * input is admitted at once: it never waits on itself.
+   * @param holder - The run.
+   * @param estimate - The bytes its derivation is expected to take.
+   * @param full - The full snapshot, whose bytes set the bound.
+   * @param signal - Aborts the wait.
+   * @returns Resolves once the run may derive.
+   */
+  async reserve(t, n, r, s) {
+    for (this.fullBytes = et(r); ; ) {
+      if (s?.throwIfAborted(), this.holds(t))
+        return;
+      const o = this.bound - this.pending(t) - n;
+      if (this.shrink(o), this.bytes <= o) {
+        this.reservations.set(t, n);
+        return;
+      }
+      if (!this.othersHold(t))
+        throw new g({
+          code: "E_TOO_LARGE",
+          message: `A scoped run needs about ${String(n)} bytes for its input, and the derived-input cache holds at most ${String(this.bound)}.`,
+          source: "run",
+          details: { reason: "derived-input", estimate: n, bound: this.bound }
+        });
+      await this.nextRelease(s);
+    }
+  }
+  /**
+   * A run published or aborted: it lets go of every input it held and its reservation. A marked
+   * input with no holder left is released; waiting runs try again.
+   * @param holder - The run.
+   */
+  releaseHolder(t) {
+    this.reservations.delete(t);
+    for (const n of [...this.live()])
+      n.holders.delete(t) && n.holders.size === 0 && n.marked && this.free(n);
+    this.shrink(), this.wake();
+  }
+  /** The graph froze: every entry is over a snapshot that has gone. */
+  freeze() {
+    for (const t of [...this.entries.values()])
+      this.entries.delete(t.key), this.evictEntry(t);
+    this.wake();
+  }
+  /** The graph is being torn down: release what nothing holds, mark the rest, cache nothing more. */
+  dispose() {
+    this.disposed = !0, this.freeze();
+  }
+  /**
+   * Mark every entry over another snapshot or store than this membership's.
+   * @param membership - The membership now being asked for.
+   */
+  sync(t) {
+    for (const n of [...this.entries.values()])
+      (n.serial !== t.serial || n.store !== t.store) && (this.entries.delete(n.key), this.evictEntry(n));
+  }
+  /**
+   * Evict unheld entries, least recently used first, until the bytes fit.
+   * @param budget - The bytes to fit in; the bound by default.
+   */
+  shrink(t = this.bound) {
+    for (const n of [...this.entries.values()]) {
+      if (this.bytes <= t)
+        return;
+      n.holders.size === 0 && (this.entries.delete(n.key), this.evictEntry(n));
+    }
+  }
+  /**
+   * Take an entry out of the cache: released at once when unheld, else marked and drained.
+   * @param entry - It.
+   */
+  evictEntry(t) {
+    t.marked = !0, t.holders.size === 0 ? this.free(t) : this.draining.add(t);
+  }
+  /**
+   * Release an entry's snapshot, unless another live entry still reaches the same one.
+   * @param entry - It.
+   */
+  free(t) {
+    this.draining.delete(t);
+    for (const n of this.live())
+      if (n !== t && n.snapshot === t.snapshot)
+        return;
+    this.options.release?.(t.snapshot);
+  }
+  /**
+   * Every live entry: cached and draining.
+   * @yields Each entry.
+   */
+  *live() {
+    yield* this.entries.values(), yield* this.draining;
+  }
+  /**
+   * Whether a run holds anything.
+   * @param holder - The run.
+   * @returns True when it does.
+   */
+  holds(t) {
+    for (const n of this.live())
+      if (n.holders.has(t))
+        return !0;
+    return !1;
+  }
+  /**
+   * Whether a run other than this one holds an input or a reservation.
+   * @param holder - The run asking.
+   * @returns True when another does.
+   */
+  othersHold(t) {
+    for (const n of this.reservations.keys())
+      if (n !== t)
+        return !0;
+    for (const n of this.live())
+      for (const r of n.holders)
+        if (r !== t)
+          return !0;
+    return !1;
+  }
+  /**
+   * The bytes other runs reserved and have not yet derived.
+   * @param holder - The run asking, left out.
+   * @returns The byte count.
+   */
+  pending(t) {
+    let n = 0;
+    for (const [r, s] of this.reservations) {
+      if (r === t)
+        continue;
+      const o = Qe([...this.live()].filter((i) => i.holders.has(r)).map(nt));
+      n += Math.max(0, s - o);
+    }
+    return n;
+  }
+  /**
+   * Resolves the next time a run lets go or the graph freezes.
+   * @param signal - Rejects the wait when aborted.
+   * @returns The wait.
+   */
+  nextRelease(t) {
+    return new Promise((n, r) => {
+      const s = () => {
+        this.waiters = this.waiters.filter((i) => i !== o), r(
+          t?.reason instanceof Error ? t.reason : new DOMException("The run was cancelled.", "AbortError")
+        );
+      }, o = () => {
+        t?.removeEventListener("abort", s), n();
+      };
+      this.waiters.push(o), t?.addEventListener("abort", s, { once: !0 });
+    });
+  }
+  /** Let every waiting run try again. */
+  wake() {
+    const t = this.waiters;
+    this.waiters = [];
+    for (const n of t)
+      n();
+  }
+}
+function tt(e, t, n) {
+  return `${String(_n(e.store))}:${String(e.serial)}:${Tn(e.nodes, e.edges)}:${t}:${n}`;
+}
+function nt(e) {
+  return [e.snapshot, e.edgeRemap, e.nodeOrigin, e.nodes, e.edges];
+}
+const re = /* @__PURE__ */ new WeakMap();
+function Le(e) {
+  return e.constructor.scopeInput === "subgraph";
+}
+function xn(e) {
+  return Le(e) ? re.get(e) : void 0;
+}
+function zn(e) {
+  return re.get(e)?.scope() ?? null;
+}
+function Oe(e) {
+  return e === "undirected" ? "undirected" : "declared";
+}
+function _t(e, t) {
+  if (t === null)
+    return e;
+  if (e === null)
+    return t;
+  const n = new Uint32Array(e.length);
+  for (let r = 0; r < e.length; r++) {
+    const s = e[r];
+    n[r] = s === E ? E : t[s];
+  }
+  return n;
+}
+function Ln(e, t, n, r) {
+  const s = n === "undirected" ? e.undirected(t) : null, o = s === null ? t : s.snapshot, i = r !== "none" && o.flags.multigraph ? o.simplified({ weights: r }) : null;
+  return {
+    snapshot: i === null ? o : i.snapshot,
+    edgeRemap: _t(s?.edgeRemap ?? null, i?.edgeRemap ?? null),
+    nodeOrigin: null
+  };
+}
+function ke(e, t) {
+  return {
+    snapshot: t.snapshot,
+    edgeRemap: _t(e.edgeRemap, t.edgeRemap),
+    nodeOrigin: e.nodeOrigin
+  };
+}
+function jn(e, t) {
+  const n = t.inducedSubgraph({ mask: e.nodes }), r = n.edgeRemap, s = he(n.snapshot.edgeCount);
+  let o = 0;
+  const { edges: i } = e;
+  for (let c = 0; c < i.length; c++) {
+    let u = i[c];
+    for (; u !== 0; ) {
+      const f = u & -u, l = c * 32 + (31 - Math.clz32(f));
+      if (u ^= f, l >= t.edgeCount)
+        continue;
+      const d = r === null ? l : r[l];
+      d !== E && (s[d >>> 5] |= 1 << (d & 31), o++);
+    }
+  }
+  const a = { snapshot: n.snapshot, edgeRemap: r, nodeOrigin: n.nodeOrigin };
+  return o === n.snapshot.edgeCount ? a : ke(a, n.snapshot.filterEdges(s));
+}
+function Dn(e, t, n, r, s) {
+  const { inputs: o, holder: i } = e, a = o.get(i, t, r, s);
+  if (a !== void 0)
+    return a;
+  const c = o.get(i, t, "declared", "none") ?? o.put(i, t, "declared", "none", jn(t, n), n);
+  let u = c;
+  return r === "undirected" && u.snapshot.directed && (u = ke(u, u.snapshot.toUndirected())), s !== "none" && u.snapshot.flags.multigraph && (u = ke(u, u.snapshot.simplified({ weights: s }))), u === c ? c : o.put(i, t, r, s, u, n);
+}
+function Tt(e, t, n, r) {
+  const s = e.getSnapshot(), o = n?.simplify ?? "sum", i = r?.scope() ?? null;
+  if (i !== null && i.graph !== s)
+    throw new Error("A run's scope was resolved against a snapshot that is no longer the graph.");
+  const a = i?.resolution, c = a === void 0 || a.nodeCount === s.nodeCount && a.edgeCount === s.edgeCount ? null : a;
+  let u = null, f = c?.nodes ?? null, l = c?.edges ?? null;
+  const d = {
+    graph: s,
+    whole: c === null,
+    nodeCount: c?.nodeCount ?? s.nodeCount,
+    edgeCount: c?.edgeCount ?? s.edgeCount,
+    derived() {
+      return u ??= c === null || r === void 0 ? Ln(e, s, t, o) : Dn(r, c, s, t, o), u;
+    },
+    subgraph() {
+      return d.derived().snapshot;
+    }
+  };
+  return Object.defineProperties(d, {
+    nodes: {
+      enumerable: !0,
+      get: () => (f ??= he(s.nodeCount, !0), f)
+    },
+    edges: {
+      enumerable: !0,
+      get: () => (l ??= he(s.edgeCount, !0), l)
+    }
+  }), d;
+}
+function Ys(e) {
+  const { graph: t, nodes: n, whole: r } = e, s = [];
+  for (let o = 0; o < t.nodeCount; o++)
+    (r || oe(n, o)) && s.push(t.ids.idOf(o));
+  return s;
+}
+function qs(e) {
+  const { graph: t, edges: n, whole: r } = e, s = t.edges.typed(ve, "u32");
+  if (s === null)
+    throw new Error(`The graph carries no "${ve}" column to name its edges by.`);
+  const { src: o, dst: i } = t.edgeList(), a = [];
+  for (let c = 0; c < t.edgeCount; c++)
+    (r || oe(n, c)) && a.push({
+      id: vn(s.data[c]),
+      row: c,
+      source: t.ids.idOf(o[c]),
+      target: t.ids.idOf(i[c])
+    });
+  return a;
+}
+const Ae = /* @__PURE__ */ new WeakMap();
+function Pn(e) {
+  let t = Ae.get(e);
+  return t === void 0 && (t = new Fn({
+    release: (n) => {
+      const { accelerator: r } = e.acceleration, s = r?.release;
+      if (typeof s == "function")
+        try {
+          s.call(r, n);
+        } catch (o) {
+          console.warn("graphty: an accelerator threw while releasing a derived input", o);
+        }
+    }
+  }), Ae.set(e, t)), t;
+}
+function Ks(e) {
+  return Ae.get(e);
+}
+function Hn(e) {
+  const { graph: t, resolution: n } = e, r = t.nodeCount + t.edgeCount, s = t.byteLength({ columns: !0, ids: !0 });
+  return r === 0 ? 0 : Math.ceil(s * (n.nodeCount + n.edgeCount) / r);
+}
+async function Zs(e, t, n, r, s) {
+  const o = Pn(t), i = {};
+  re.set(e, { inputs: o, holder: i, scope: n });
+  try {
+    if (Le(e)) {
+      const a = n();
+      a !== null && (a.resolution.nodeCount !== a.graph.nodeCount || a.resolution.edgeCount !== a.graph.edgeCount) && await o.reserve(i, Hn(a), a.graph, r);
+    }
+    return await s();
+  } finally {
+    re.delete(e), o.releaseHolder(i);
+  }
+}
+class O extends Error {
+  /**
+   * Creates an option validation error
+   * @param optionKey - The key of the option that failed validation
+   * @param message - The validation error message
+   */
+  constructor(t, n) {
+    super(`Option '${t}': ${n}`), this.optionKey = t, this.name = "OptionValidationError";
+  }
+}
+function Un(e, t, n) {
+  if (t == null) {
+    if (n.required)
+      throw new O(e, "is required but was not provided");
+    return;
+  }
+  switch (n.type) {
+    case "number":
+      rt(e, t, n, !1);
+      break;
+    case "integer":
+      rt(e, t, n, !0);
+      break;
+    case "boolean":
+      if (typeof t != "boolean")
+        throw new O(e, `must be a boolean, got ${typeof t}`);
+      break;
+    case "string":
+      if (typeof t != "string")
+        throw new O(e, `must be a string, got ${typeof t}`);
+      break;
+    case "select":
+      Gn(e, t, n);
+      break;
+    case "nodeId":
+      if (typeof t != "string" && typeof t != "number")
+        throw new O(e, `must be a string or number (node ID), got ${typeof t}`);
+      break;
+    default:
+      throw new O(e, `has unknown type '${n.type}'`);
+  }
+}
+function rt(e, t, n, r) {
+  if (typeof t != "number")
+    throw new O(e, `must be a number, got ${typeof t}`);
+  if (Number.isNaN(t))
+    throw new O(e, "must not be NaN");
+  if (!Number.isFinite(t))
+    throw new O(e, "must be finite");
+  if (r && !Number.isInteger(t))
+    throw new O(e, `must be an integer, got ${t}`);
+  if (n.min !== void 0 && t < n.min)
+    throw new O(e, `must be >= ${n.min}, got ${t}`);
+  if (n.max !== void 0 && t > n.max)
+    throw new O(e, `must be <= ${n.max}, got ${t}`);
+}
+function Gn(e, t, n) {
+  if (!n.options || n.options.length === 0)
+    throw new O(e, "is a select type but has no options defined");
+  if (!n.options.map((s) => s.value).includes(t)) {
+    const s = n.options.map((o) => `'${String(o.value)}'`).join(", ");
+    throw new O(e, `must be one of [${s}], got '${String(t)}'`);
+  }
+}
+function Bn(e, t) {
+  const n = {};
+  for (const [r, s] of Object.entries(e)) {
+    const i = t?.[r] ?? s.default;
+    Un(r, i, s), n[r] = i;
+  }
+  return n;
+}
+function Xs(e) {
+  return e;
+}
+function Vn(e, t, n = Tt(e, Oe(t))) {
+  return Jn(n.subgraph(), t);
+}
+function Qs(e) {
+  const t = e.getSnapshot();
+  return t.flags.multigraph ? t.edgeCount - t.simplified({ weights: "sum" }).snapshot.edgeCount : 0;
+}
+function Jn(e, t) {
+  const n = new tn({
+    directed: t !== "undirected"
+  }), { ids: r } = e;
+  for (let a = 0; a < e.nodeCount; a++)
+    n.addNode(r.idOf(a));
+  const { src: s, dst: o, weights: i } = e.edgeList();
+  for (let a = 0; a < e.edgeCount; a++) {
+    const c = r.idOf(s[a]), u = r.idOf(o[a]), f = i === null ? 1 : i[a];
+    n.addEdge(c, u, f);
+  }
+  return n;
+}
+const V = new Zt("algorithm"), st = /* @__PURE__ */ new WeakMap();
+function Wn(e, t, n) {
+  if (e.scopeInput !== void 0 && e.scopeInput !== t)
+    throw new g({
+      code: "E_BAD_COMMAND",
+      message: `the algorithm registered as "${n}" publishes scopeInput "${e.scopeInput}" and its class declares "${t}". Declare it once, as "static scopeInput", and leave it out of the descriptor.`,
+      source: "registry",
+      details: {
+        kind: "algorithm",
+        field: "descriptor.scopeInput",
+        key: e.key,
+        declared: t,
+        published: e.scopeInput
+      }
+    });
+  let r = st.get(e);
+  r === void 0 && (r = /* @__PURE__ */ new Map(), st.set(e, r));
+  let s = r.get(t);
+  return s === void 0 && (s = { ...e, scopeInput: t }, r.set(t, s)), s;
+}
+const Ge = class Ge {
+  /**
+   * Getter for schema options
+   *
+   * Algorithms that use the new schema-based options should access
+   * options via this getter.
+   * @returns The resolved schema options
+   */
+  get schemaOptions() {
+    return this._schemaOptions;
+  }
+  /**
+   * Creates a new algorithm instance
+   * @param g - The graph to run the algorithm on
+   * @param options - Optional configuration options (uses schema defaults if not provided)
+   */
+  constructor(t, n) {
+    this.graph = t, this._schemaOptions = this.resolveOptions(n);
+  }
+  /**
+   * The `@graphty/algorithms` Graph this run reads, built from the element's graph snapshot.
+   *
+   * This is the ONLY way an algorithm should obtain its input. The `Node` and `Edge` objects the
+   * data manager also holds are render objects -- each `Node` builds a Babylon mesh in its
+   * constructor -- and reading the graph out of them ties every algorithm to a renderer and to
+   * whatever part of a data load the scene has caught up with.
+   * @param mode - the shape this algorithm needs; see {@link AlgorithmGraphMode}
+   * @returns a freshly built Graph for the algorithm package
+   */
+  algorithmGraph(t) {
+    return Vn(this.graph.getDataManager(), t, this.input(Oe(t)));
+  }
+  /**
+   * The graph this run computes over, in one orientation: its scope's compact snapshot when the
+   * class declares {@link Algorithm.scopeInput} and runs as a run, else the whole graph. Both
+   * seams below read through it.
+   * @param orientation - `"declared"` or `"undirected"`.
+   * @param options - How parallel edges merge; the class's {@link Algorithm.parallelEdges} by
+   *   default, else `"sum"`.
+   * @returns The input.
+   * @internal
+   */
+  input(t, n) {
+    const r = n?.simplify ?? this.constructor.parallelEdges, s = r === void 0 ? n : { ...n, simplify: r };
+    return Tt(this.graph.getDataManager(), t, s, xn(this));
+  }
+  /**
+   * One edge's record, by the id an input named it by: for an attribute the snapshot does not
+   * carry yet, such as a flow capacity. It is not a topology read -- the ids come from the input
+   * -- and it goes away once the store carries attribute columns.
+   * @param id - The edge's session id, from `scopeEdges`.
+   * @returns The record the edge was loaded from, or undefined.
+   * @internal
+   */
+  edgeRecord(t) {
+    return this.graph.getDataManager().getEdge(t)?.data;
+  }
+  /**
+   * The route an algorithm with an accelerated implementation takes.
+   *
+   * It is the counterpart of {@link algorithmGraph} for the algorithms `@graphty/algorithms`
+   * can dispatch: instead of copying the snapshot into an object graph, the work runs over the
+   * snapshot itself, on the attached accelerator or on the index-based CPU port, and the adapter
+   * writes one loop over an index-aligned result either way.
+   *
+   * THE DECISION IS TAKEN ONCE, HERE, BEFORE ANY WORK STARTS. The controller answers "the policy
+   * is off", "no accelerator", "below `acceleration.minNodes`" or "this accelerator does not
+   * implement that" up front, and under `acceleration="required"` it throws `E_NO_ACCELERATOR`
+   * rather than answering quietly. After the work has started there is no second decision: a
+   * failure from the accelerator propagates with its code and fails the run, because a number
+   * that silently came from somewhere else is worse than no number.
+   * @param capability - The accelerator member this work would use, such as `"pageRank"`.
+   * @param mode - The shape this algorithm needs; see {@link AlgorithmGraphMode}. `"undirected"`
+   *   takes the snapshot's undirected view, which is what collapses a reciprocal pair into one
+   *   edge.
+   * @returns The snapshot, the edge map onto it, and the runner.
+   * @example
+   * ```ts
+   * const { snapshot, run } = this.accelerated("connectedComponents", "undirected");
+   * const { value, precision } = await run((dispatch, s) => dispatch.connectedComponents(s));
+   * const group = value.labels[snapshot.ids.indexOf(nodeId)];
+   * ```
+   */
+  accelerated(t, n) {
+    const { snapshot: r, edgeRemap: s } = this.input(Oe(n)).derived(), o = this.graph.acceleration, i = { capability: t, nodeCount: r.nodeCount };
+    return {
+      snapshot: r,
+      edgeRemap: s,
+      run: async (a) => {
+        const c = await o.run(
+          i,
+          (u) => a(Je(sn(u)), r)
+        );
+        return c.accelerated ? { value: c.value, precision: c.precision } : { value: await a(Je(null), r), precision: an };
+      }
+    };
+  }
+  /**
+   * The dense row of a node the reader named in an option.
+   *
+   * A search takes its source as an id and the snapshot answers in indices, so this is where the
+   * two meet -- and where an id that names no node in the graph is reported as what it is: an
+   * option whose value is outside the permitted range, carrying the option's name and what was
+   * passed, rather than a silent empty result or a search from row zero.
+   * @param snapshot - The graph the work runs over.
+   * @param option - The option the id came from, named in the error.
+   * @param id - The node id the reader gave.
+   * @returns The node's dense row.
+   * @throws A `GraphtyError` with `E_OPTION_RANGE` when the graph has no such node.
+   */
+  nodeIndex(t, n, r) {
+    const s = t.ids.indexOf(r);
+    if (s === E)
+      throw new g({
+        code: "E_OPTION_RANGE",
+        message: `the graph has no node "${String(r)}", so "${n}" names nothing to run from`,
+        source: "run",
+        details: { option: n, value: r }
+      });
+    return s;
+  }
+  /**
+   * Resolves and validates options against the schema
+   * @param options - User-provided options (partial)
+   * @returns Fully resolved options with defaults applied
+   */
+  resolveOptions(t) {
+    const n = this.constructor.optionsSchema;
+    return Object.keys(n).length === 0 ? {} : Bn(n, t);
+  }
+  /**
+   * Gets the algorithm type
+   * @returns The algorithm type identifier
+   */
+  get type() {
+    return this.constructor.type;
+  }
+  /**
+   * Gets the algorithm namespace
+   * @returns The algorithm namespace identifier
+   */
+  get namespace() {
+    return this.constructor.namespace;
+  }
+  /**
+   * Compute this algorithm and publish what it produced as a result object.
+   *
+   * This is the entry point the run machinery calls, and it is the one that makes an algorithm
+   * startable as a `Run`: it takes a signal it must throw from, a progress channel, a yield, and
+   * the run id the result is published under -- and it RETURNS the result rather than writing it
+   * somewhere a caller has to go looking for. `run()` is the 1.10 entry point beside it, which
+   * returns nothing and can be neither watched nor stopped.
+   *
+   * The default refuses, because an algorithm that has not been migrated genuinely cannot answer
+   * a run: it publishes through side effects under its own names and has no result object to
+   * hand back. Both shipped families -- a metric and a declared algorithm -- override it.
+   * @param _context - A signal, a progress channel and a yield.
+   * @param runId - The id the result is published under.
+   * @param _fields - The catalogue's descriptors for this algorithm's fields, when the caller
+   *   holds them.
+   * @returns The result, or undefined when there was nothing to compute.
+   * @throws A `GraphtyError` with code `E_UNSUPPORTED` when this algorithm has no result to
+   *   publish.
+   */
+  publishResult(t, n, r) {
+    return Promise.reject(
+      new g({
+        code: "E_UNSUPPORTED",
+        message: `The "${this.namespace}:${this.type}" algorithm writes its result through side effects and cannot be started as a run.`,
+        source: "run",
+        target: { kind: "run", id: n },
+        details: { algorithm: `${this.namespace}:${this.type}` }
+      })
+    );
+  }
+  /**
+   * Registers an algorithm class in the global registry
+   * @param cls - The algorithm class to register
+   * @returns The registered algorithm class
+   */
+  static register(t) {
+    const n = t, r = String(n.type), s = String(n.namespace), { descriptor: o, cost: i, costUnits: a, version: c } = n;
+    return o !== void 0 && cn({
+      descriptor: Wn(o, n.scopeInput ?? "none", `${s}:${r}`),
+      namespace: s,
+      type: r,
+      ...i === void 0 ? {} : { cost: i },
+      ...a === void 0 ? {} : { costUnits: a },
+      ...c === void 0 ? {} : { version: c }
+    }), V.set(`${s}:${r}`, t), t;
+  }
+  /**
+   * Gets an algorithm instance from the registry
+   * @param g - The graph to run the algorithm on
+   * @param namespace - The algorithm namespace
+   * @param type - The algorithm type
+   * @param options - Optional algorithm-specific options to pass to constructor
+   * @returns A new instance of the algorithm, or null if not found
+   */
+  static get(t, n, r, s) {
+    const o = V.get(`${n}:${r}`);
+    return o ? new o(t, s) : null;
+  }
+  /**
+   * Gets an algorithm class from the registry
+   * @param namespace - The algorithm namespace
+   * @param type - The algorithm type
+   * @returns The algorithm class, or null if not found
+   */
+  static getClass(t, n) {
+    return V.get(`${t}:${n}`) ?? null;
+  }
+  /**
+   * Get the options schema for this algorithm
+   * @returns The options schema, or an empty object if no options defined
+   * @deprecated Use getZodOptionsSchema() instead
+   */
+  static getOptionsSchema() {
+    return this.optionsSchema;
+  }
+  /**
+   * Check if this algorithm has configurable options
+   * @returns true if the algorithm has at least one option defined
+   * @deprecated Use hasZodOptions() instead
+   */
+  static hasOptions() {
+    return Object.keys(this.optionsSchema).length > 0;
+  }
+  /**
+   * Get the Zod-based options schema for this algorithm.
+   * @returns The Zod options schema, or an empty object if no schema defined
+   */
+  static getZodOptionsSchema() {
+    return this.zodOptionsSchema ?? {};
+  }
+  /**
+   * Check if this algorithm has a Zod-based options schema.
+   * @returns true if the algorithm has a Zod options schema defined
+   */
+  static hasZodOptions() {
+    return this.zodOptionsSchema !== void 0 && Object.keys(this.zodOptionsSchema).length > 0;
+  }
+  /**
+   * Get all registered algorithm names.
+   * @param namespace - Optional namespace to filter by
+   * @returns Array of algorithm names in "namespace:type" format
+   */
+  static getRegisteredAlgorithms(t) {
+    const n = [];
+    for (const r of V.keys())
+      (!t || r.startsWith(`${t}:`)) && n.push(r);
+    return n.sort();
+  }
+  /**
+   * Get all registered algorithm types.
+   * This method is provided for API consistency with DataSource.
+   * @returns Array of algorithm keys in "namespace:type" format
+   * @since 1.5.0
+   * @example
+   * ```typescript
+   * const types = Algorithm.getRegisteredTypes();
+   * console.log('Available algorithms:', types);
+   * // ['graphty:betweenness', 'graphty:closeness', 'graphty:degree', ...]
+   * ```
+   */
+  static getRegisteredTypes() {
+    return this.getRegisteredAlgorithms();
+  }
+};
+Ge.optionsSchema = {};
+let Se = Ge;
+const ot = 3, Yn = 0.1;
+function m(e, t) {
+  return Number.isInteger(e) ? e.toLocaleString(t) : Number(e.toFixed(ot)).toLocaleString(t, { maximumFractionDigits: ot });
+}
+function qn(e, t, n) {
+  const r = e.fields.find((s) => s.name === t);
+  return r === void 0 ? t : n === "technical" ? r.technicalName : r.plainName.toLowerCase();
+}
+function ue(e, t, n) {
+  const r = e.fields.find((s) => s.name === t)?.unit;
+  return r === void 0 ? "" : n === 1 && r.endsWith("s") ? ` ${r.slice(0, -1)}` : ` ${r}`;
+}
+function H(e, t) {
+  const n = e.graph[t];
+  return typeof n == "number" && Number.isFinite(n) ? n : void 0;
+}
+function Kn(e) {
+  return e[0];
+}
+function Zn(e, t, n) {
+  const { locale: r, audience: s } = n, o = qn(e, "value", s), i = Kn(t.top);
+  if (i === void 0 || t.median === null)
+    return `Nothing was measured, so there is no ${o} to report.`;
+  const a = [
+    `${i.label} has the highest ${o}, at ${m(i.value, r)}${ue(e, "value", i.value)}.`,
+    `The typical element sits at ${m(t.median, r)}${ue(e, "value", t.median)}.`
+  ];
+  return t.measured > 0 && t.tiedAtMin / t.measured >= Yn && t.min !== null && a.push(
+    `${m(t.tiedAtMin, r)} of ${m(t.measured, r)} sit at the lowest value, ${m(t.min, r)}${ue(e, "value", t.min)}.`
+  ), t.count > t.measured && a.push(`${m(t.count - t.measured, r)} were not measured.`), a.join(" ");
+}
+function Xn(e, t, n) {
+  const { locale: r } = n, s = t.groups ?? [];
+  if (s.length === 0)
+    return "Nothing was grouped, so there are no groups to report.";
+  const o = s[0], i = [
+    `${m(s.length, r)} ${s.length === 1 ? "group" : "groups"} were found,`,
+    `the largest holding ${m(o.size, r)} of ${m(t.measured, r)}.`
+  ], a = H(e, "modularity");
+  return a !== void 0 && i.push(`Modularity is ${m(a, r)}.`), i.join(" ");
+}
+function Qn(e, t) {
+  const { locale: n } = t, r = H(e, "hops"), s = H(e, "cost");
+  if (r === void 0 && s === void 0)
+    return "No route was found.";
+  const o = [];
+  return r !== void 0 && o.push(`The route runs ${m(r, n)} ${r === 1 ? "hop" : "hops"}.`), s !== void 0 && o.push(`Its total cost is ${m(s, n)}.`), o.join(" ");
+}
+function er(e, t, n) {
+  const { locale: r } = n, s = H(e, "count") ?? t.measured, o = e.shape === "edge-set" ? "edge" : "node";
+  return s === 0 ? `No ${o}s were selected.` : `${m(s, r)} ${s === 1 ? o : `${o}s`} were selected.`;
+}
+function tr(e, t) {
+  const { pairs: n } = e.graph, r = Array.isArray(n) ? n.length : 0;
+  return r === 0 ? "No pairs were found." : `${m(r, t.locale)} ${r === 1 ? "pair was" : "pairs were"} found.`;
+}
+function nr(e, t) {
+  const n = H(e, "steps");
+  return n === void 0 || n === 0 ? "The series is empty." : `The series covers ${m(n, t.locale)} ${n === 1 ? "step" : "steps"}.`;
+}
+function it(e, t) {
+  return e.measured === 0 ? "The run produced no values." : `The run covered ${m(e.measured, t.locale)} of ${m(e.count, t.locale)}.`;
+}
+function rr(e, t) {
+  const n = e.summary(), { shape: r } = e;
+  switch (r) {
+    case "node-metric":
+    case "edge-metric":
+      return Zn(e, n, t);
+    case "community":
+    case "layered-grouping":
+    case "category-table":
+      return Xn(e, n, t);
+    case "path":
+      return Qn(e, t);
+    case "node-set":
+    case "edge-set":
+      return er(e, n, t);
+    case "pair-list":
+      return tr(e, t);
+    case "temporal":
+      return nr(e, t);
+    case "fact":
+      return it(n, t);
+    default:
+      return it(n, t);
+  }
+}
+function eo(e, t) {
+  const n = t === "node", r = n ? e.nodeValue : e.edgeValue, s = n ? e.nodeHas : e.edgeHas, o = n ? e.nodeIdOf : e.edgeIdOf;
+  return {
+    value: r,
+    has: s ?? ((i, a) => sr(r(i, a))),
+    idOf: o ?? null
+  };
+}
+function sr(e) {
+  return e != null;
+}
+function W(e) {
+  return e == null || e === !1 || e === "" ? !1 : Array.isArray(e) ? e.length > 0 : typeof e == "object" ? Object.keys(e).length > 0 : !0;
+}
+function Ne(e, t) {
+  if (e === t)
+    return !0;
+  if (Array.isArray(e) && Array.isArray(t))
+    return e.length === t.length && e.every((n, r) => Ne(n, t[r]));
+  if (at(e) && at(t)) {
+    const n = Object.keys(e);
+    return n.length === Object.keys(t).length && n.every((r) => Ne(e[r], t[r]));
+  }
+  return !1;
+}
+function at(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
+}
+function y(e, t, n, r = {}) {
+  return new g({
+    code: "E_BAD_SELECTOR",
+    message: `${e} (at character ${String(n)} of ${JSON.stringify(t)})`,
+    source: "style",
+    details: { ...r, position: n, where: t }
+  });
+}
+const or = Object.freeze({
+  "[": "index, slice, wildcard and filter expressions",
+  "]": "index, slice, wildcard and filter expressions",
+  "{": "multi-select hashes",
+  "}": "multi-select hashes",
+  ",": "multi-select lists",
+  "*": "wildcards",
+  "@": "the current-node reference",
+  ":": "slices"
+}), ir = ["&&", "||", "==", "!=", "<=", ">=", "!", "<", ">", ".", "(", ")"];
+function Ft(e) {
+  return /[A-Za-z_]/.test(e);
+}
+function xt(e) {
+  return /[A-Za-z0-9_]/.test(e);
+}
+function de(e, t, n) {
+  for (let r = t + 1; r < e.length; r++) {
+    if (e[r] === "\\") {
+      r++;
+      continue;
+    }
+    if (e[r] === n)
+      return r;
+  }
+  throw y(`A ${n} is opened and never closed`, e, t, { delimiter: n });
+}
+function ar(e) {
+  let t = "";
+  for (let n = 0; n < e.length; n++) {
+    if (e[n] === "\\" && (e[n + 1] === "'" || e[n + 1] === "\\")) {
+      t += e[n + 1], n++;
+      continue;
+    }
+    t += e[n];
+  }
+  return t;
+}
+function cr(e, t, n) {
+  const r = n.replace(/\\`/g, "`");
+  try {
+    return JSON.parse(r);
+  } catch {
+    throw y(
+      `A literal between backticks must be JSON, so a bare word needs quotes: write \`"${r}"\` rather than \`${r}\``,
+      e,
+      t,
+      { literal: r }
+    );
+  }
+}
+function ur(e, t, n) {
+  try {
+    const r = JSON.parse(n);
+    if (typeof r == "string")
+      return r;
+  } catch {
+  }
+  throw y(`A quoted attribute name follows JSON's rules for a string, and ${n} does not`, e, t, {
+    name: n
+  });
+}
+function dr(e) {
+  const t = [];
+  let n = 0;
+  for (; n < e.length; ) {
+    const r = e.charAt(n);
+    if (/\s/.test(r)) {
+      n++;
+      continue;
+    }
+    const s = or[r];
+    if (s !== void 0)
+      throw y(`A selector does not support ${s}`, e, n, { construct: s });
+    if (r === "|" && e.charAt(n + 1) !== "|")
+      throw y("A selector does not support pipe expressions", e, n, {
+        construct: "pipe expressions"
+      });
+    if (r === "&" && e.charAt(n + 1) !== "&")
+      throw y("A selector does not support expression references", e, n, {
+        construct: "expression references"
+      });
+    const o = ir.find((i) => e.startsWith(i, n));
+    if (o !== void 0) {
+      t.push({ kind: "operator", text: o, at: n }), n += o.length;
+      continue;
+    }
+    if (r === "`") {
+      const i = de(e, n, "`");
+      t.push({
+        kind: "literal",
+        text: "",
+        value: cr(e, n, e.slice(n + 1, i)),
+        at: n
+      }), n = i + 1;
+      continue;
+    }
+    if (r === "'") {
+      const i = de(e, n, "'");
+      t.push({ kind: "literal", text: "", value: ar(e.slice(n + 1, i)), at: n }), n = i + 1;
+      continue;
+    }
+    if (r === '"') {
+      const i = de(e, n, '"');
+      t.push({ kind: "identifier", text: ur(e, n, e.slice(n, i + 1)), at: n }), n = i + 1;
+      continue;
+    }
+    if (Ft(r)) {
+      let i = n + 1;
+      for (; i < e.length && xt(e.charAt(i)); )
+        i++;
+      t.push({ kind: "identifier", text: e.slice(n, i), at: n }), n = i;
+      continue;
+    }
+    throw /[0-9-]/.test(r) ? y("A number in a selector goes between backticks, so write `5` rather than 5", e, n, {
+      character: r
+    }) : y(`${JSON.stringify(r)} is not something a selector can contain`, e, n, {
+      character: r
+    });
+  }
+  return t.push({ kind: "end", text: "", at: e.length }), t;
+}
+const lr = Object.freeze({
+  "!=": "!=",
+  "<": "<",
+  "<=": "<=",
+  "==": "==",
+  ">": ">",
+  ">=": ">="
+});
+function C(e) {
+  return e.tokens[e.index];
+}
+function _(e, t) {
+  const n = C(e);
+  return n.kind === "operator" && n.text === t;
+}
+function fr(e) {
+  const t = C(e), n = [];
+  for (; ; ) {
+    const r = C(e);
+    if (r.kind !== "identifier")
+      throw y("A `.` must be followed by an attribute name", e.where, r.at);
+    if (r.text.includes("."))
+      throw y(
+        `A quoted attribute name may not contain a dot: ${JSON.stringify(r.text)} would be indistinguishable from two names`,
+        e.where,
+        r.at,
+        { segment: r.text }
+      );
+    if (e.index++, _(e, "("))
+      throw y(
+        `A selector does not support functions, so ${r.text}(...) cannot be called here`,
+        e.where,
+        r.at,
+        { construct: "functions", function: r.text }
+      );
+    if (n.push(r.text), !_(e, "."))
+      return { kind: "path", path: n.join("."), at: t.at };
+    e.index++;
+  }
+}
+function pr(e) {
+  const t = C(e);
+  if (t.kind === "literal")
+    return e.index++, { kind: "literal", value: t.value };
+  if (t.kind === "identifier")
+    return fr(e);
+  if (_(e, "(")) {
+    e.index++;
+    const n = zt(e);
+    if (!_(e, ")"))
+      throw y("A `(` is opened and never closed", e.where, t.at);
+    return e.index++, { kind: "group", inner: n };
+  }
+  throw y(
+    t.kind === "end" ? "The selector ends where an attribute name, a literal or a `(` should be" : `${JSON.stringify(t.text)} is where an attribute name, a literal or a \`(\` should be`,
+    e.where,
+    t.at
+  );
+}
+function Ee(e) {
+  if (!_(e, "!"))
+    return pr(e);
+  const t = C(e);
+  e.index++;
+  const n = Ee(e);
+  if (n.kind === "path" && n.path.includes("."))
+    throw y(
+      `In JMESPath \`!\` binds tighter than \`.\`, so !${n.path} means (!${n.path.split(".")[0]})${n.path.slice(n.path.indexOf("."))} rather than the opposite of ${n.path}. Write !(${n.path}) for that`,
+      e.where,
+      t.at,
+      { path: n.path }
+    );
+  return { kind: "not", operand: n };
+}
+function ct(e) {
+  const t = Ee(e), n = C(e), r = n.kind === "operator" ? lr[n.text] : void 0;
+  return r === void 0 ? t : (e.index++, { kind: "compare", operator: r, left: t, right: Ee(e) });
+}
+function ut(e) {
+  let t = ct(e);
+  for (; _(e, "&&"); )
+    e.index++, t = { kind: "and", left: t, right: ct(e) };
+  return t;
+}
+function zt(e) {
+  let t = ut(e);
+  for (; _(e, "||"); )
+    e.index++, t = { kind: "or", left: t, right: ut(e) };
+  return t;
+}
+function hr(e) {
+  const t = { where: e, tokens: dr(e), index: 0 }, n = zt(t), r = C(t);
+  if (r.kind !== "end")
+    throw y(
+      `${JSON.stringify(r.text)} is left over at the end of the selector`,
+      e,
+      r.at
+    );
+  return n;
+}
+function P(e, t) {
+  switch (e.kind) {
+    case "path":
+      t.includes(e.path) || t.push(e.path);
+      return;
+    case "group":
+      P(e.inner, t);
+      return;
+    case "not":
+      P(e.operand, t);
+      return;
+    case "and":
+    case "or":
+    case "compare":
+      P(e.left, t), P(e.right, t);
+      return;
+    default:
+      return;
+  }
+}
+function k(e, t) {
+  switch (e.kind) {
+    case "path": {
+      const { path: n } = e, { value: r } = t;
+      return (s) => {
+        const o = r(s, n);
+        return o === void 0 ? null : o;
+      };
+    }
+    case "literal": {
+      const { value: n } = e;
+      return () => n;
+    }
+    case "group":
+      return k(e.inner, t);
+    case "not": {
+      const n = k(e.operand, t);
+      return (r) => !W(n(r));
+    }
+    case "and": {
+      const n = k(e.left, t), r = k(e.right, t);
+      return (s) => {
+        const o = n(s);
+        return W(o) ? r(s) : o;
+      };
+    }
+    case "or": {
+      const n = k(e.left, t), r = k(e.right, t);
+      return (s) => {
+        const o = n(s);
+        return W(o) ? o : r(s);
+      };
+    }
+    default:
+      return yr(e.operator, e.left, e.right, t);
+  }
+}
+const gr = Object.freeze({
+  "<": (e, t) => e < t,
+  "<=": (e, t) => e <= t,
+  ">": (e, t) => e > t,
+  ">=": (e, t) => e >= t
+});
+function mr(e, t) {
+  return e.kind === "literal" ? e : t.kind === "literal" ? t : null;
+}
+function yr(e, t, n, r) {
+  if (e === "==" || e === "!=") {
+    const a = e === "==", c = t.kind === "literal", u = mr(t, n), f = c ? n : t;
+    if (u !== null && u.value === null && f.kind === "path") {
+      const { path: p } = f, { has: w } = r;
+      return (h) => w(h, p) !== a;
+    }
+    const l = k(t, r), d = k(n, r);
+    if (u !== null && u.value !== null && typeof u.value != "object") {
+      const { value: p } = u, w = c ? d : l;
+      return (h) => w(h) === p === a;
+    }
+    return (p) => Ne(l(p), d(p)) === a;
+  }
+  const s = k(t, r), o = k(n, r), i = gr[e];
+  return (a) => {
+    const c = s(a), u = o(a);
+    return typeof c == "number" && typeof u == "number" ? i(c, u) : null;
+  };
+}
+function T(e, t) {
+  switch (e.kind) {
+    case "compare":
+    case "not": {
+      const n = k(e, t);
+      return (r) => n(r) === !0;
+    }
+    case "group":
+      return T(e.inner, t);
+    case "and": {
+      const n = T(e.left, t), r = T(e.right, t);
+      return (s) => n(s) && r(s);
+    }
+    case "or": {
+      const n = T(e.left, t), r = T(e.right, t);
+      return (s) => n(s) || r(s);
+    }
+    default: {
+      const n = k(e, t);
+      return (r) => W(n(r));
+    }
+  }
+}
+function br(e) {
+  return e.split(".").map((t) => wr(t) ? t : JSON.stringify(t)).join(".");
+}
+function wr(e) {
+  if (e === "" || !Ft(e[0]))
+    return !1;
+  for (let t = 1; t < e.length; t++)
+    if (!xt(e[t]))
+      return !1;
+  return !0;
+}
+function to(e, t) {
+  const { has: n } = e;
+  return (r) => n(r, t);
+}
+function no(e, t) {
+  const { idOf: n } = e;
+  if (n === null)
+    throw new g({
+      code: "E_UNSUPPORTED",
+      message: 'This session cannot evaluate an "ids" selector, because it cannot say which id sits at which row. Painting the layer anyway would colour elements it never named.',
+      source: "style",
+      details: { match: "ids" }
+    });
+  return (r) => t.has(n(r));
+}
+function ro(e, t, n) {
+  const { value: r } = e;
+  return (s) => {
+    const o = n();
+    if (o === void 0)
+      return !1;
+    const i = r(s, t);
+    return typeof i == "number" && Number.isFinite(i) && i >= o;
+  };
+}
+function so(e, t) {
+  return (n) => {
+    const r = e.bits(t);
+    return r !== null && oe(r, n);
+  };
+}
+function oo(e, t) {
+  const n = hr(e), r = [];
+  if (P(n, r), r.length === 0) {
+    let s = n;
+    for (; s.kind === "group"; )
+      s = s.inner;
+    const o = s.kind === "literal" && typeof s.value == "string";
+    throw y(
+      o ? "The selector is a quoted string literal, which is always true, so it would match every element. Remove the outer quotes so it is read as an expression" : 'The selector reads no attribute of the element, so it answers the same for every element. Write { match: "everything" } for a layer that really is meant to paint the whole graph',
+      e,
+      0,
+      { constant: !0 }
+    );
+  }
+  return { paths: Object.freeze(r), test: T(n, t) };
+}
+const Ie = "results", vr = "$";
+function Y(e, t) {
+  return t === void 0 ? `${Ie}.${e}` : `${Ie}.${e}.${t}`;
+}
+function Or(e) {
+  return `Group ${String(e)}`;
+}
+function Lt(e, t) {
+  const n = Number(e), r = Number(t);
+  return Number.isFinite(n) && Number.isFinite(r) && String(n) === String(e) && String(r) === String(t) ? n - r : String(e).localeCompare(String(t));
+}
+const jt = {
+  // -- per element ---------------------------------------------------------------------
+  value: {
+    meaning: "The number this metric measured for this element.",
+    scope: "element",
+    types: ["number", "integer"]
+  },
+  rank: {
+    meaning: "Where this element sits when every measured element is ordered best first, starting at 1.",
+    scope: "element",
+    types: ["integer"]
+  },
+  percentile: {
+    meaning: "The share of measured elements this one ranks at or above, from 0 to 1.",
+    scope: "element",
+    types: ["number"]
+  },
+  group: {
+    meaning: "Which group this node was placed in.",
+    scope: "element",
+    types: ["integer", "string"]
+  },
+  groupSize: {
+    meaning: "How many nodes share this node's group.",
+    scope: "element",
+    types: ["integer"]
+  },
+  level: {
+    meaning: "How many levels out from the start this node sits, counting the start as 0.",
+    scope: "element",
+    types: ["integer"]
+  },
+  levelSize: {
+    meaning: "How many nodes share this node's level.",
+    scope: "element",
+    types: ["integer"]
+  },
+  category: {
+    meaning: "The category this node was sorted into.",
+    scope: "element",
+    types: ["string"]
+  },
+  score: {
+    meaning: "How strongly this node belongs to its category.",
+    scope: "element",
+    types: ["number"]
+  },
+  onPath: {
+    meaning: "Whether this element is on the route the run found.",
+    scope: "element",
+    types: ["boolean"]
+  },
+  order: {
+    meaning: "This node's position along the route, counting the source as 0.",
+    scope: "element",
+    types: ["integer"]
+  },
+  in: {
+    meaning: "Whether this element is in the set the run selected.",
+    scope: "element",
+    types: ["boolean"]
+  },
+  // -- per graph -----------------------------------------------------------------------
+  min: {
+    meaning: "The lowest value any measured element carries.",
+    scope: "graph",
+    types: ["number"]
+  },
+  max: {
+    meaning: "The highest value any measured element carries.",
+    scope: "graph",
+    types: ["number"]
+  },
+  median: {
+    meaning: "The middle value once the measured elements are ordered.",
+    scope: "graph",
+    types: ["number"]
+  },
+  mean: {
+    meaning: "The average value across the measured elements.",
+    scope: "graph",
+    types: ["number"]
+  },
+  measured: {
+    meaning: "How many elements the run produced a value for. Smaller than the scope when some elements have nothing to measure. Distinct from RunResult.measured, which counts the nodes and edges the run looked at.",
+    scope: "graph",
+    types: ["integer"]
+  },
+  normalization: {
+    meaning: 'How the values were scaled before publication: "max", "min-max" or "none".',
+    scope: "graph",
+    types: ["string"]
+  },
+  tiedAtMin: {
+    meaning: "How many measured elements sit at the lowest value, which is what says whether a colour ramp is about to paint most of the graph one colour.",
+    scope: "graph",
+    types: ["integer"]
+  },
+  groupCount: {
+    meaning: "How many groups the partition has.",
+    scope: "graph",
+    types: ["integer"]
+  },
+  modularity: {
+    meaning: "How much better this partition is than a random one, from -0.5 to 1.",
+    scope: "graph",
+    types: ["number"]
+  },
+  sizes: {
+    meaning: "The size of each group or level, largest first.",
+    scope: "graph",
+    types: ["table"]
+  },
+  levelCount: {
+    meaning: "How many levels the walk reached.",
+    scope: "graph",
+    types: ["integer"]
+  },
+  categories: {
+    meaning: "One row per category, with its name and how many elements fell into it.",
+    scope: "graph",
+    types: ["table"]
+  },
+  length: {
+    meaning: "How many nodes are on the route.",
+    scope: "graph",
+    types: ["integer"]
+  },
+  cost: {
+    meaning: "What the route costs in total, summing the weight of every edge on it.",
+    scope: "graph",
+    types: ["number"]
+  },
+  hops: {
+    meaning: "How many edges are on the route.",
+    scope: "graph",
+    types: ["integer"]
+  },
+  count: {
+    meaning: "How many elements are in the set.",
+    scope: "graph",
+    types: ["integer"]
+  },
+  pairs: {
+    meaning: "One row per scored pair of elements, best first.",
+    scope: "graph",
+    types: ["table"]
+  },
+  steps: {
+    meaning: "One row per time step, with the step's window and what was visible in it.",
+    scope: "graph",
+    types: ["table"]
+  },
+  series: {
+    meaning: "One row per tracked quantity, carrying its value at every step.",
+    scope: "graph",
+    types: ["table"]
+  },
+  rates: {
+    meaning: "One row per tracked quantity, carrying how fast it changed between steps.",
+    scope: "graph",
+    types: ["table"]
+  },
+  changeThreshold: {
+    meaning: "The rate of change above which a step counts as a change rather than drift.",
+    scope: "graph",
+    types: ["number"]
+  }
+}, io = Object.keys(jt), je = {
+  "node-metric": {
+    shape: "node-metric",
+    primaryField: "value",
+    nodeFields: ["value", "rank", "percentile"],
+    edgeFields: [],
+    graphFields: ["min", "max", "median", "mean", "measured", "normalization", "tiedAtMin"],
+    optionalGraphFields: [],
+    headlineScalar: !1,
+    layer: "encoding"
+  },
+  "edge-metric": {
+    shape: "edge-metric",
+    primaryField: "value",
+    nodeFields: [],
+    edgeFields: ["value", "rank", "percentile"],
+    graphFields: ["min", "max", "median", "mean", "measured", "normalization", "tiedAtMin"],
+    optionalGraphFields: [],
+    headlineScalar: !1,
+    layer: "encoding"
+  },
+  community: {
+    shape: "community",
+    primaryField: "group",
+    nodeFields: ["group", "groupSize"],
+    edgeFields: [],
+    graphFields: ["groupCount", "sizes"],
+    // Only an algorithm that scores its own partition can publish modularity. Label
+    // propagation and connected components do not, and a required field they cannot fill
+    // would be a number invented to satisfy a table.
+    optionalGraphFields: ["modularity"],
+    headlineScalar: !1,
+    layer: "encoding"
+  },
+  "layered-grouping": {
+    shape: "layered-grouping",
+    primaryField: "level",
+    nodeFields: ["level", "levelSize"],
+    edgeFields: [],
+    graphFields: ["levelCount", "sizes"],
+    optionalGraphFields: [],
+    headlineScalar: !1,
+    layer: "encoding"
+  },
+  "category-table": {
+    shape: "category-table",
+    primaryField: "category",
+    nodeFields: ["category", "score", "rank"],
+    edgeFields: [],
+    graphFields: ["categories"],
+    optionalGraphFields: [],
+    headlineScalar: !1,
+    layer: "encoding"
+  },
+  path: {
+    shape: "path",
+    primaryField: "onPath",
+    nodeFields: ["onPath", "order"],
+    // The edges of the route carry membership but not a position: an edge's place in the
+    // route is the order of the node it leaves.
+    edgeFields: ["onPath"],
+    graphFields: ["length", "cost", "hops"],
+    optionalGraphFields: [],
+    headlineScalar: !1,
+    layer: "highlight"
+  },
+  "node-set": {
+    shape: "node-set",
+    primaryField: "in",
+    nodeFields: ["in"],
+    edgeFields: [],
+    graphFields: ["count"],
+    optionalGraphFields: [],
+    headlineScalar: !0,
+    layer: "highlight"
+  },
+  "edge-set": {
+    shape: "edge-set",
+    primaryField: "in",
+    nodeFields: [],
+    edgeFields: ["in"],
+    graphFields: ["count"],
+    optionalGraphFields: [],
+    headlineScalar: !0,
+    layer: "highlight"
+  },
+  "pair-list": {
+    shape: "pair-list",
+    primaryField: "pairs",
+    nodeFields: [],
+    edgeFields: [],
+    graphFields: ["pairs"],
+    optionalGraphFields: [],
+    headlineScalar: !1,
+    layer: "none"
+  },
+  temporal: {
+    shape: "temporal",
+    primaryField: "series",
+    nodeFields: [],
+    edgeFields: [],
+    graphFields: ["steps", "series", "rates", "changeThreshold"],
+    optionalGraphFields: [],
+    headlineScalar: !1,
+    layer: "none"
+  },
+  fact: {
+    shape: "fact",
+    primaryField: null,
+    nodeFields: [],
+    edgeFields: [],
+    graphFields: [],
+    optionalGraphFields: [],
+    headlineScalar: !1,
+    layer: "none"
+  }
+};
+function Re(e) {
+  return je[e];
+}
+function ao(e) {
+  return je[e].layer === "highlight";
+}
+function co(e, t) {
+  const n = je[e], r = [], s = [
+    { names: n.nodeFields, kind: "node" },
+    { names: n.edgeFields, kind: "edge" },
+    { names: n.graphFields, kind: "graph" }
+  ];
+  for (const { names: o, kind: i } of s)
+    for (const a of o) {
+      const c = t.find((f) => f.name === a && f.kind === i);
+      if (c === void 0) {
+        r.push({
+          field: a,
+          kind: i,
+          reason: `shape "${e}" requires a ${i} field named "${a}"`
+        });
+        continue;
+      }
+      const u = jt[a].types;
+      u.includes(c.type) || r.push({
+        field: a,
+        kind: i,
+        reason: `${i} field "${a}" is typed "${c.type}", not ${u.map((f) => `"${f}"`).join(" or ")}`
+      });
+    }
+  return n.headlineScalar && !kr(n, t) && r.push({
+    field: null,
+    kind: "graph",
+    reason: `shape "${e}" requires one graph-level scalar of its own beside "count"`
+  }), r;
+}
+function kr(e, t) {
+  const n = [...e.graphFields, ...e.optionalGraphFields];
+  return t.some((r) => r.kind === "graph" && !n.includes(r.name));
+}
+const Ar = 3;
+function Sr(e, t) {
+  if (e === t)
+    return 0;
+  const n = new Uint32Array(t.length + 1), r = new Uint32Array(t.length + 1);
+  for (let s = 0; s <= t.length; s++)
+    n[s] = s;
+  for (let s = 1; s <= e.length; s++) {
+    r[0] = s;
+    for (let o = 1; o <= t.length; o++) {
+      const i = n[o - 1] + (e[s - 1] === t[o - 1] ? 0 : 1);
+      r[o] = Math.min(r[o - 1] + 1, n[o] + 1, i);
+    }
+    n.set(r);
+  }
+  return n[t.length];
+}
+function Nr(e, t, n = Ar) {
+  const r = e.toLowerCase(), s = t.map((o) => ({
+    candidate: o,
+    distance: Sr(r, o.toLowerCase())
+  }));
+  return s.sort((o, i) => o.distance - i.distance || o.candidate.localeCompare(i.candidate)), Object.freeze(s.slice(0, Math.max(n, 0)).map((o) => o.candidate));
+}
+function Me(e) {
+  return typeof e == "string" ? e : "runId" in e ? e.runId : e.id;
+}
+function Er(e) {
+  return typeof e == "string" ? void 0 : e.shape;
+}
+function Ir(e, t) {
+  return e.fields.some((n) => n.name === t) || t in e.graph;
+}
+class Rr {
+  #e;
+  /**
+   * Build the API over a registry.
+   * @param registry - Where runs are looked up.
+   */
+  constructor(t) {
+    this.#e = t;
+  }
+  /**
+   * The published path of a run's field.
+   *
+   * With no field the path names the run's primary field -- `value` for a metric, `group` for a
+   * partition, `onPath` for a route -- so a caller binds an encoding to a run without knowing
+   * what that algorithm calls its number. A `fact` result has no primary field and addresses
+   * its whole result object instead.
+   * @param run - The run, its result, or its id.
+   * @param field - The field name; the shape's primary field when absent.
+   * @returns The path.
+   */
+  path(t, n) {
+    const r = Me(t);
+    if (n !== void 0)
+      return Y(r, n);
+    const s = Er(t) ?? this.#e.entry(r)?.shape, o = s === void 0 ? null : Re(s).primaryField;
+    return o === null ? Y(r) : Y(r, o);
+  }
+  /**
+   * The same field, written so a selector expression can read it.
+   *
+   * The quoting is the whole point: a run id carries its algorithm's name, and a hyphenated
+   * name lexes its hyphen as subtraction, so a path pasted into an expression unquoted is a
+   * refused selector rather than a comparison. Nothing here decides WHICH field -- that is
+   * {@link ResultsApi.path}'s job and this defers to it -- so the two can never name different
+   * columns.
+   * @param run - The run, its result, or its id.
+   * @param field - The field name; the shape's primary field when absent.
+   * @returns The path with every segment quoted that needs it.
+   */
+  term(t, n) {
+    return br(n === void 0 ? this.path(t) : this.path(t, n));
+  }
+  /**
+   * One run's result.
+   *
+   * The answer always comes from the registry, even when the caller passed a result object: the
+   * question is what this session holds, and a result the session never registered is not it.
+   * @param run - The run, its result, or its id.
+   * @returns The result, or undefined when the session holds no such run or it has not
+   *   finished.
+   */
+  get(t) {
+    return this.#e.entry(Me(t))?.result;
+  }
+  /**
+   * Whether a run, or one of its fields, is available to read.
+   * @param run - The run, its result, or its id.
+   * @param field - The field name; asks only about the run itself when absent.
+   * @returns True when the path would resolve.
+   */
+  has(t, n) {
+    const r = this.get(t);
+    return r === void 0 ? !1 : n === void 0 || Ir(r, n);
+  }
+  /**
+   * Every run that has published a result, as an expression editor reads them.
+   * @returns One root per finished run, in the order the runs were started.
+   */
+  get roots() {
+    const t = [];
+    for (const n of this.#e.entries())
+      n.result !== void 0 && t.push(Object.freeze({ runId: n.id, label: n.label, fields: n.result.fields }));
+    return Object.freeze(t);
+  }
+}
+const Dt = /* @__PURE__ */ new WeakMap();
+function uo(e, t) {
+  const n = Dt.get(e)?.entry(Me(t));
+  return n?.result === void 0 ? void 0 : n.execution;
+}
+function lo(e) {
+  const t = new Rr(e);
+  return Dt.set(t, e), t;
+}
+const Mr = 20, le = 100, $r = 100, Cr = Object.freeze([]), _r = Object.freeze(["max", "min-max", "none"]);
+function Pt(e) {
+  return typeof e == "string" && _r.includes(e);
+}
+function fo(e) {
+  return {
+    length: e.length,
+    get: (t) => e[t]
+  };
+}
+const Tr = Object.freeze({
+  measured: 0,
+  min: Number.NaN,
+  max: Number.NaN,
+  mean: Number.NaN,
+  median: Number.NaN,
+  tiedAtMin: 0,
+  smallestPositive: null
+});
+function Ht(e) {
+  const { length: t } = e, n = new Float64Array(t);
+  let r = 0;
+  for (let d = 0; d < t; d++) {
+    const p = e.get(d);
+    Number.isFinite(p) && (n[r] = p, r++);
+  }
+  if (r === 0)
+    return { length: t, ...Tr };
+  let s = Number.POSITIVE_INFINITY, o = Number.NEGATIVE_INFINITY, i = Number.POSITIVE_INFINITY, a = 0, c = 0;
+  for (let d = 0; d < r; d++) {
+    const p = n[d];
+    p < s && (s = p), p > o && (o = p), p > 0 && p < i && (i = p);
+    const w = p - c, h = a + w;
+    c = h - a - w, a = h;
+  }
+  const u = n.slice(0, r).sort(), f = u[Math.floor((r - 1) / 2)];
+  let l = 0;
+  for (; l < r && u[l] === s; )
+    l++;
+  return {
+    length: t,
+    measured: r,
+    min: s,
+    max: o,
+    mean: a / r,
+    median: f,
+    tiedAtMin: l,
+    smallestPositive: Number.isFinite(i) ? i : null
+  };
+}
+function Ut(e) {
+  const t = Ht(e);
+  return { view: Object.freeze({
+    length: e.length,
+    get: (r) => e.get(r),
+    min: t.min,
+    max: t.max,
+    mean: t.mean,
+    median: t.median
+  }), statistics: t };
+}
+function De(e) {
+  const t = e.filter((i) => Number.isFinite(i.value)).map((i) => ({ entry: i, label: String(i.id) }));
+  t.sort((i, a) => i.entry.value !== a.entry.value ? a.entry.value - i.entry.value : i.label === a.label ? 0 : i.label < a.label ? -1 : 1);
+  const n = t.length, r = [];
+  let s = 0, o = Number.NaN;
+  for (let i = 0; i < n; i++) {
+    const { entry: a } = t[i];
+    a.value !== o && (s = i + 1, o = a.value), r.push(
+      Object.freeze({
+        id: a.id,
+        value: a.value,
+        rank: s,
+        percentile: (n - s + 1) / n
+      })
+    );
+  }
+  return Object.freeze(r);
+}
+function Fr(e, t) {
+  let n = Math.min(t, e.length);
+  for (; n > 0 && n < e.length && e[n].rank === e[n - 1].rank; )
+    n--;
+  if (n === e.length || n === t)
+    return Object.freeze({ entries: e.slice(0, n), leftOut: null, reason: null });
+  const { value: r } = e[n];
+  let s = n;
+  for (; s < e.length && e[s].value === r; )
+    s++;
+  const o = s - n, i = `${String(o)} tie at ${String(r)}, and taking them would make ${String(n + o)}, more than the ${String(t)} asked for, so ${n === 0 ? "none are" : `only the top ${String(n)} are`} taken.`;
+  return Object.freeze({
+    entries: e.slice(0, n),
+    leftOut: Object.freeze({ value: r, count: o }),
+    reason: i
+  });
+}
+function xr(e) {
+  const { smallestPositive: t } = e;
+  if (e.measured === 0 || !(e.max > 0) || t === null)
+    return !1;
+  const n = e.min > 0 ? e.min : t;
+  return Math.log10(e.max) > Math.log10(n);
+}
+function zr(e) {
+  return e.measured === 0 || !(e.median > 0) || e.max / e.median <= $r ? "linear" : xr(e) ? "log" : "linear";
+}
+function Lr(e, t, n, r) {
+  if (!(t > e))
+    return { binCount: 1, indexOf: () => 0, rangeOf: () => [e, t] };
+  if (r) {
+    const o = t - e + 1, i = Math.ceil(o / Math.min(o, n)), a = Math.ceil(o / i);
+    return {
+      binCount: a,
+      indexOf: (c) => Math.min(Math.floor((c - e) / i), a - 1),
+      rangeOf: (c) => {
+        const u = e + c * i;
+        return [u, Math.min(u + i - 1, t)];
+      }
+    };
+  }
+  const s = (t - e) / n;
+  return {
+    binCount: n,
+    indexOf: (o) => Math.min(Math.floor((o - e) / s), n - 1),
+    rangeOf: (o) => [
+      e + o * s,
+      o === n - 1 ? t : e + (o + 1) * s
+    ]
+  };
+}
+function jr(e, t, n, r, s) {
+  const o = e > 0 ? 0 : 1, i = o === 0 ? e : n;
+  if (!(t > 0) || i === null || !(i > 0))
+    return null;
+  const a = Math.log10(i), c = Math.log10(t);
+  if (!(c > a))
+    return null;
+  const u = r - o;
+  if (u < 1)
+    return null;
+  const f = (c - a) / u;
+  return {
+    binCount: r,
+    indexOf: (l) => {
+      if (!(l > 0))
+        return 0;
+      const d = Math.floor((Math.log10(l) - a) / f);
+      return o + Math.min(Math.max(d, 0), u - 1);
+    },
+    rangeOf: (l) => {
+      if (l < o)
+        return [e, 0];
+      const d = l - o, p = d === 0 ? i : 10 ** (a + d * f), w = d === u - 1 ? t : 10 ** (a + (d + 1) * f);
+      if (!s)
+        return [p, w];
+      const h = d === 0 ? i : Math.ceil(p);
+      return [h, d === u - 1 ? t : Math.max(h, Math.ceil(w) - 1)];
+    }
+  };
+}
+function Dr(e) {
+  if (e === void 0)
+    return Mr;
+  if (!Number.isInteger(e) || e < 1 || e > le)
+    throw new g({
+      code: "E_OPTION_RANGE",
+      source: "run",
+      message: `A histogram takes between 1 and ${le} bins; ${String(e)} was asked for.`,
+      details: { option: "bins", value: e, min: 1, max: le }
+    });
+  return e;
+}
+function Pr(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  for (let r = 0; r < e.length; r++) {
+    const s = e.get(r);
+    if (!Number.isFinite(s))
+      continue;
+    const o = n.get(s);
+    if (o === void 0) {
+      if (n.size >= t)
+        return null;
+      n.set(s, 1);
+      continue;
+    }
+    n.set(s, o + 1);
+  }
+  return n;
+}
+function Hr(e, t) {
+  const n = Dr(t?.bins), r = t?.integerValued ?? !1, s = Ht(e), o = zr(s), i = Pr(e, n);
+  if (i !== null) {
+    if (i.size === 0)
+      return Object.freeze({
+        bins: Cr,
+        // Nothing was measured, so nothing is on any axis. Reported as linear rather
+        // than as the request, because "log scale" over an empty chart is the same false
+        // caption this whole return type exists to prevent.
+        scale: "linear",
+        suggestedScale: "linear",
+        binning: "empty"
+      });
+    const l = [...i.entries()].sort((d, p) => d[0] - p[0]).map(([d, p]) => Object.freeze({ from: d, to: d, count: p }));
+    return Object.freeze({
+      bins: Object.freeze(l),
+      // One bar per distinct value has no bands to space, so neither axis was applied to
+      // it. Saying "linear" here is what stops a caption claiming a logarithmic layout of
+      // a chart that has none.
+      scale: "linear",
+      suggestedScale: o,
+      binning: "per-value"
+    });
+  }
+  const c = t?.scale === "log" || t?.scale === "auto" && o === "log" ? jr(s.min, s.max, s.smallestPositive, n, r) : null, u = c ?? Lr(s.min, s.max, n, r), f = new Array(u.binCount).fill(0);
+  for (let l = 0; l < e.length; l++) {
+    const d = e.get(l);
+    Number.isFinite(d) && (f[u.indexOf(d)] += 1);
+  }
+  return Object.freeze({
+    bins: Object.freeze(
+      f.map((l, d) => {
+        const [p, w] = u.rangeOf(d);
+        return Object.freeze({ from: p, to: w, count: l });
+      })
+    ),
+    // `plan` is null exactly when a logarithmic layout was asked for and could not be built,
+    // which is the case a caption must not get wrong.
+    scale: c === null ? "linear" : "log",
+    suggestedScale: o,
+    binning: "banded"
+  });
+}
+const Ur = 10, Gr = 10;
+function dt(e) {
+  const t = { ids: [], records: [], index: /* @__PURE__ */ new Map() };
+  if (e === void 0)
+    return t;
+  for (const n of e) {
+    const r = t.index.get(n.id);
+    if (r === void 0) {
+      t.index.set(n.id, t.ids.length), t.ids.push(n.id), t.records.push({ ...n.values });
+      continue;
+    }
+    Object.assign(t.records[r], n.values);
+  }
+  return t;
+}
+function $e(e, t) {
+  const { records: n } = e;
+  return {
+    length: n.length,
+    get: (r) => Gt(n[r][t])
+  };
+}
+function Pe(e, t) {
+  return e.ids.map((n, r) => ({ id: n, value: Gt(e.records[r][t]) }));
+}
+function Gt(e) {
+  return typeof e == "number" ? e : Number.NaN;
+}
+function He(e) {
+  return typeof e == "string" || typeof e == "number";
+}
+function fe(e) {
+  return e.type === "number" || e.type === "integer";
+}
+function v(e, t, n) {
+  e[t] === void 0 && (e[t] = n);
+}
+function se(e, t, n) {
+  e[t] === void 0 && (e[t] = n);
+}
+function Bt(e, t) {
+  const n = /* @__PURE__ */ new Map();
+  for (const r of e.records) {
+    const s = r[t];
+    He(s) && n.set(s, (n.get(s) ?? 0) + 1);
+  }
+  return n;
+}
+function Br(e) {
+  const t = [...e.entries()].map(([n, r]) => ({ group: n, size: r }));
+  return t.sort((n, r) => r.size - n.size || Lt(n.group, r.group)), Object.freeze(t.map((n) => Object.freeze(n)));
+}
+function Vt(e, t) {
+  const n = e.find((r) => r.name === t)?.normalization;
+  return Pt(n) ? n : "none";
+}
+function lt(e, t, n) {
+  const { statistics: r } = Ut($e(e, "value"));
+  for (const s of De(Pe(e, "value"))) {
+    const o = e.index.get(s.id);
+    o !== void 0 && (se(e.records[o], "rank", s.rank), se(e.records[o], "percentile", s.percentile));
+  }
+  r.measured > 0 && (v(t, "min", r.min), v(t, "max", r.max), v(t, "median", r.median), v(t, "mean", r.mean)), v(t, "measured", r.measured), v(t, "tiedAtMin", r.tiedAtMin), v(t, "normalization", Vt(n, "value"));
+}
+function ft(e, t, n, r, s) {
+  const o = Bt(e, n);
+  for (const i of e.records) {
+    const a = i[n];
+    He(a) && se(i, r, o.get(a));
+  }
+  v(t, s, o.size), v(t, "sizes", Br(o));
+}
+function Vr(e, t) {
+  for (const r of De(Pe(e, "score"))) {
+    const s = e.index.get(r.id);
+    s !== void 0 && se(e.records[s], "rank", r.rank);
+  }
+  const n = [...Bt(e, "category").entries()].map(([r, s]) => ({
+    category: String(r),
+    count: s
+  }));
+  n.sort((r, s) => s.count - r.count || Lt(r.category, s.category)), v(t, "categories", Object.freeze(n.map((r) => Object.freeze(r))));
+}
+function J(e, t) {
+  let n = 0;
+  for (const r of e.records)
+    r[t] === !0 && n++;
+  return n;
+}
+function pt(e, t) {
+  let n = 0;
+  for (const r of e.records)
+    r[t] !== void 0 && n++;
+  return n;
+}
+function Jr(e, t, n, r, s) {
+  switch (e) {
+    case "node-metric":
+      lt(t, r, s);
+      break;
+    case "edge-metric":
+      lt(n, r, s);
+      break;
+    case "community":
+      ft(t, r, "group", "groupSize", "groupCount");
+      break;
+    case "layered-grouping":
+      ft(t, r, "level", "levelSize", "levelCount");
+      break;
+    case "category-table":
+      Vr(t, r);
+      break;
+    case "path":
+      v(r, "length", J(t, "onPath")), v(r, "hops", J(n, "onPath"));
+      break;
+    case "node-set":
+      v(r, "count", J(t, "in"));
+      break;
+    case "edge-set":
+      v(r, "count", J(n, "in"));
+      break;
+  }
+}
+function Wr(e) {
+  switch (e) {
+    case "node-metric":
+    case "edge-metric":
+      return "value";
+    case "category-table":
+      return "score";
+    case "layered-grouping":
+      return "level";
+    default:
+      return null;
+  }
+}
+function Yr(e, t, n) {
+  if (!Array.isArray(e))
+    return;
+  const r = [];
+  for (const s of e) {
+    if (typeof s != "object" || s === null)
+      continue;
+    const o = s, i = o.group ?? o.category, a = o.size ?? o.count;
+    if (He(i) && typeof a == "number" && r.push(Object.freeze(n ? { group: i, size: a, name: Or(r.length + 1) } : { group: i, size: a })), r.length === t)
+      break;
+  }
+  return Object.freeze(r);
+}
+class qr {
+  #e;
+  #t;
+  #n;
+  #r;
+  #s;
+  #o;
+  #i = /* @__PURE__ */ new Map();
+  #a = /* @__PURE__ */ new Map();
+  #c = /* @__PURE__ */ new Map();
+  #u;
+  /**
+   * Build a result around storage that has already been filled and frozen.
+   * @param init - What the run published.
+   * @param nodes - The published nodes.
+   * @param edges - The published edges.
+   * @param graph - The graph half, frozen.
+   */
+  constructor(t, n, r, s) {
+    this.runId = t.runId, this.shape = t.shape, this.fields = Object.freeze([...t.fields]), this.measured = Object.freeze({ nodes: t.measured.nodes, edges: t.measured.edges }), this.graph = s, this.#e = n, this.#t = r, this.#n = t.caveats, this.#r = t.durationMs, this.#s = t.labelOf ?? (() => {
+    }), this.#o = t.reading ?? rr;
+  }
+  /**
+   * One node's fields.
+   * @param id - The node id.
+   * @returns The fields, or undefined when the run produced nothing for that node.
+   */
+  node(t) {
+    const n = this.#e.index.get(t);
+    return n === void 0 ? void 0 : this.#e.records[n];
+  }
+  /**
+   * One edge's fields.
+   * @param id - The edge id.
+   * @returns The fields, or undefined when the run produced nothing for that edge.
+   */
+  edge(t) {
+    const n = this.#t.index.get(t);
+    return n === void 0 ? void 0 : this.#t.records[n];
+  }
+  /**
+   * One numeric field as a column.
+   *
+   * The view reads straight through to the result's own storage and its four figures were
+   * computed on the first call, so a histogram, a colour ramp's domain and a summary all walk
+   * one column rather than three copies of it.
+   * @param field - The field name.
+   * @returns A view over the values, without an object per element.
+   * @throws A GraphtyError coded E_UNKNOWN_ATTRIBUTE when the run published no such field, or
+   *   E_BAD_COMMAND when the field is not a number published per element.
+   */
+  column(t) {
+    return this.#p(t).view;
+  }
+  /**
+   * The highest-ranked elements on one field.
+   *
+   * Elements with equal values share a rank and come back in printed-id order, so the top of a
+   * ranking does not reshuffle between two runs that measured the same thing.
+   * @param field - The field to rank on.
+   * @param limit - How many entries to return; the whole ranking when absent.
+   * @returns The entries, best first.
+   * @throws A GraphtyError coded E_OPTION_RANGE when the limit is not a whole number of
+   *   entries, E_UNKNOWN_ATTRIBUTE when the run published no such field, or E_BAD_COMMAND when
+   *   the field is not a number published per element.
+   */
+  ranking(t, n) {
+    n !== void 0 && this.#d(n, "limit");
+    const r = this.#a.get(t) ?? this.#g(t);
+    return n === void 0 ? r : Object.freeze(r.slice(0, n));
+  }
+  /**
+   * The top `n` elements on one field, cut only between tie groups: a group of equal values is
+   * taken whole, and only when all of it fits inside `n`. Kept per field and `n`, because a
+   * top selector asks once per element it paints.
+   * @param field - The field to rank on.
+   * @param n - The most elements the top may hold.
+   * @returns The elements taken, and the tie group left out when there was one.
+   * @throws A GraphtyError coded E_OPTION_RANGE when n is not a whole number of entries,
+   *   E_UNKNOWN_ATTRIBUTE when the run published no such field, or E_BAD_COMMAND when the
+   *   field is not a number published per element.
+   */
+  top(t, n) {
+    const r = `${String(n)}:${t}`, s = this.#c.get(r);
+    if (s !== void 0)
+      return s;
+    const o = Fr(this.ranking(t), this.#d(n, "n"));
+    return this.#c.set(r, o), o;
+  }
+  /**
+   * Refuse a count of entries that is not a whole number.
+   * @param limit - The count.
+   * @param option - What the caller called it, for the refusal.
+   * @returns The count.
+   * @throws A GraphtyError coded E_OPTION_RANGE when it is not a whole number of entries.
+   */
+  #d(t, n) {
+    if (!Number.isInteger(t) || t < 0)
+      throw new g({
+        code: "E_OPTION_RANGE",
+        source: "run",
+        message: `A ranking limit is a whole number of entries, not ${String(t)}.`,
+        details: { option: n, value: t, min: 0 },
+        target: { kind: "run", id: this.runId }
+      });
+    return t;
+  }
+  /**
+   * The distribution of one numeric field.
+   *
+   * Whether the field counts things is read off its own descriptor rather than passed in, so a
+   * count metric gets whole-number band edges without the caller knowing that it should.
+   * @param field - The field to bin.
+   * @param options - How to cut the bins.
+   * @returns The distribution, carrying the scale that was applied as well as the bars.
+   * @throws A GraphtyError coded E_OPTION_RANGE when the bin count is outside the permitted
+   *   range, E_UNKNOWN_ATTRIBUTE when the run published no such field, or E_BAD_COMMAND when
+   *   the field is not a number published per element.
+   */
+  histogram(t, n) {
+    const r = this.#l(t), s = r.kind === "edge" ? this.#t : this.#e;
+    return Hr($e(s, t), {
+      ...n,
+      integerValued: r.type === "integer"
+    });
+  }
+  /**
+   * The bounded form of this result.
+   *
+   * Everything on it is either a single figure or a list the element cut to a fixed length, so
+   * the object is the same size for a graph of a hundred nodes and a graph of a million.
+   * @returns The summary.
+   */
+  summary() {
+    return this.#u ??= this.#m(), this.#u;
+  }
+  /**
+   * What this result means, in one sentence of plain language.
+   * @param options - The locale and how technical to be.
+   * @returns The sentence.
+   */
+  reading(t) {
+    return this.#o(this, t ?? {});
+  }
+  /**
+   * The descriptor of one numeric per-element field, without complaining when there is none.
+   *
+   * A summary asks this rather than {@link Result.#descriptorFor} because a summary must not
+   * throw: a run whose field list does not declare the field its shape calls primary is a
+   * defect in that run, and the summary's job is to say what it can about the result rather
+   * than to refuse to describe it at all.
+   * @param field - The field name.
+   * @returns Its descriptor, or null when the run published no numeric field under that name.
+   */
+  #h(t) {
+    const n = this.fields.find((r) => r.name === t && r.kind !== "graph");
+    return n !== void 0 && fe(n) ? n : null;
+  }
+  /**
+   * The descriptor of one numeric field the run published per element.
+   * @param field - The field name.
+   * @returns Its descriptor.
+   * @throws A GraphtyError naming what went wrong, with the readable fields in its details.
+   */
+  #l(t) {
+    const n = this.fields.filter((o) => o.name === t), r = n.find((o) => o.kind !== "graph"), s = this.fields.filter((o) => o.kind !== "graph" && fe(o)).map((o) => o.name);
+    if (r === void 0)
+      throw n.length > 0 ? new g({
+        code: "E_BAD_COMMAND",
+        source: "run",
+        message: `"${t}" is a graph-level field of run "${this.runId}"; read it from result.graph.`,
+        details: { field: t, kind: "graph", available: s },
+        target: { kind: "run", id: this.runId }
+      }) : new g({
+        code: "E_UNKNOWN_ATTRIBUTE",
+        source: "run",
+        message: `Run "${this.runId}" published no field named "${t}".`,
+        details: { field: t, available: s, candidates: Nr(t, s) },
+        target: { kind: "run", id: this.runId }
+      });
+    if (!fe(r))
+      throw new g({
+        code: "E_BAD_COMMAND",
+        source: "run",
+        message: `"${t}" is typed "${r.type}", which is not a column of numbers.`,
+        details: { field: t, type: r.type, available: s },
+        target: { kind: "run", id: this.runId }
+      });
+    return r;
+  }
+  /**
+   * The half of the result a per-element field belongs to.
+   * @param field - The field name.
+   * @returns The nodes or the edges.
+   * @throws A GraphtyError naming what went wrong.
+   */
+  #f(t) {
+    return this.#l(t).kind === "edge" ? this.#t : this.#e;
+  }
+  /**
+   * One field's column and statistics, computed on the first ask and kept.
+   * @param field - The field name.
+   * @returns The view and the statistics behind it.
+   * @throws A GraphtyError naming what went wrong.
+   */
+  #p(t) {
+    const n = this.#i.get(t);
+    if (n !== void 0)
+      return n;
+    const r = Ut($e(this.#f(t), t));
+    return this.#i.set(t, r), r;
+  }
+  /**
+   * Rank one field for the first time and keep the answer.
+   * @param field - The field to rank on.
+   * @returns The whole ranking, best first.
+   * @throws A GraphtyError naming what went wrong.
+   */
+  #g(t) {
+    const n = De(Pe(this.#f(t), t));
+    return this.#a.set(t, n), n;
+  }
+  /**
+   * Build the bounded form of this result.
+   * @returns The summary.
+   */
+  #m() {
+    const t = Wr(this.shape), n = t === null || this.#h(t) === null ? null : t, r = n === null ? null : this.#p(n).statistics, s = r !== null && r.measured > 0 ? r : null, o = n === null ? [] : this.ranking(n, Ur).map(
+      (u) => Object.freeze({
+        id: u.id,
+        label: this.#s(u.id) ?? String(u.id),
+        value: u.value,
+        rank: u.rank,
+        percentile: u.percentile
+      })
+    ), i = {
+      count: this.#y(),
+      measured: r === null ? this.#b() : r.measured,
+      min: s === null ? null : s.min,
+      max: s === null ? null : s.max,
+      median: s === null ? null : s.median,
+      mean: s === null ? null : s.mean,
+      tiedAtMin: r === null ? 0 : r.tiedAtMin,
+      normalization: this.#w(n),
+      top: Object.freeze(o),
+      caveats: this.#n,
+      durationMs: this.#r
+    }, a = this.graph.sizes ?? this.graph.categories, c = Yr(a, Gr, this.shape === "community");
+    return Object.freeze(c === void 0 ? i : { ...i, groups: c });
+  }
+  /**
+   * How many elements this result was computed over.
+   *
+   * A shape publishes per-element fields for nodes, for edges or for neither, and the scope a
+   * summary reports is the half or halves it actually measures. A shape that publishes nothing
+   * per element reports none, rather than borrowing the graph's size to look busy.
+   * @returns The count.
+   */
+  #y() {
+    const t = Re(this.shape), n = t.nodeFields.length > 0 ? this.measured.nodes : 0, r = t.edgeFields.length > 0 ? this.measured.edges : 0;
+    return n + r;
+  }
+  /**
+   * How many elements carry the shape's primary field, for a shape that measures no number.
+   * @returns The count.
+   */
+  #b() {
+    const t = Re(this.shape), { primaryField: n } = t;
+    if (n === null)
+      return 0;
+    const r = t.nodeFields.includes(n) ? pt(this.#e, n) : 0, s = t.edgeFields.includes(n) ? pt(this.#t, n) : 0;
+    return r + s;
+  }
+  /**
+   * How this result's values were scaled.
+   * @param valueField - The field a summary describes, or null when the shape measures no
+   *   number.
+   * @returns The normalisation the run published, the one its field declares, or "none".
+   */
+  #w(t) {
+    const n = this.graph.normalization;
+    return Pt(n) ? n : t === null ? "none" : Vt(this.fields, t);
+  }
+}
+function Kr(e) {
+  const t = dt(e.nodes), n = dt(e.edges), r = { ...e.graph };
+  Jr(e.shape, t, n, r, e.fields);
+  for (const s of t.records)
+    Object.freeze(s);
+  for (const s of n.records)
+    Object.freeze(s);
+  return new qr(e, t, n, Object.freeze(r));
+}
+const Zr = "Computed on the whole graph; values kept for the scope only.";
+function Jt(e) {
+  const { graph: t, resolution: n } = e;
+  return n.nodeCount === t.nodeCount && n.edgeCount === t.edgeCount;
+}
+function Ce(e, t, n) {
+  return t !== E && t < n && oe(e, t);
+}
+function pe(e, t) {
+  return `${String(e)} ${t}${e === 1 ? "" : "s"}`;
+}
+function Xr(e, t) {
+  if (!e)
+    return Zr;
+  const { nodeCount: n, edgeCount: r } = t.resolution;
+  return t.reading === "induced" ? `Computed on the induced subgraph of ${pe(n, "node")}.` : `Computed on the subgraph of ${pe(n, "node")} and the ${pe(r, "edge")} in scope.`;
+}
+function Qr(e, t) {
+  const n = zn(e);
+  if (n === null || Jt(n))
+    return t;
+  const { graph: r, resolution: s } = n, o = (a) => Ce(s.nodes, r.ids.indexOf(a.id), r.nodeCount), i = (a) => Ce(s.edges, kn(r, a.id), r.edgeCount);
+  return {
+    ...t,
+    ...t.nodes === void 0 ? {} : { nodes: t.nodes.filter(o) },
+    ...t.edges === void 0 ? {} : { edges: t.edges.filter(i) },
+    caveats: {
+      ...t.caveats,
+      notes: [...t.caveats.notes, Xr(Le(e), n)]
+    }
+  };
+}
+function po(e, t, n) {
+  if (n === null || Jt(n))
+    return;
+  const { graph: r, resolution: s } = n;
+  for (const o of e) {
+    if (o.type !== "node-id" && o.type !== "node-set")
+      continue;
+    const i = t[o.name], a = Array.isArray(i) ? i : [i];
+    for (const c of a) {
+      if (typeof c != "string" && typeof c != "number")
+        continue;
+      const u = r.ids.indexOf(c);
+      if (u !== E && !Ce(s.nodes, u, r.nodeCount))
+        throw new g({
+          code: "E_OPTION_RANGE",
+          message: `"${o.name}" names node "${String(c)}", which is outside the run's scope`,
+          source: "run",
+          details: { option: o.name, value: c, reason: "outside-scope" }
+        });
+    }
+  }
+}
+function es(e) {
+  const t = e.styles?.config.data.knownFields.nodeLabelPath ?? null;
+  if (t === null)
+    return;
+  const n = e.getDataManager();
+  return (r) => {
+    const s = n.getNode(r)?.data[t];
+    return typeof s == "string" || typeof s == "number" ? String(s) : void 0;
+  };
+}
+function ho(e) {
+  return { exact: !0, precision: "f64", notes: [], ...e };
+}
+const ts = 1024, ns = 16;
+function rs() {
+  return {
+    input: () => {
+      throw new Error("A detached run context reads no graph: call computeRun, which binds the input.");
+    },
+    signal: new AbortController().signal,
+    report: () => {
+    },
+    yieldNow: () => new Promise((e) => {
+      setTimeout(e, 0);
+    })
+  };
+}
+async function go(e, t, n, r) {
+  const s = n.length;
+  e.report({ phase: t, completed: 0, total: s });
+  let o = performance.now();
+  for (let i = 0; i < s; i++)
+    i > 0 && i % ts === 0 && (e.signal.throwIfAborted(), e.report({ phase: t, completed: i, total: s }), performance.now() - o >= ns && (await e.yieldNow(), o = performance.now())), r(n[i], i);
+  e.signal.throwIfAborted(), e.report({ phase: t, completed: s, total: s });
+}
+function ss(e, t, n) {
+  const r = n?.find((o) => o.name === e.name && o.kind === e.kind), s = {
+    name: e.name,
+    plainName: r?.plainName ?? e.name,
+    technicalName: r?.technicalName ?? e.name,
+    kind: e.kind,
+    type: e.type,
+    path: Y(t, e.name),
+    ...r?.unit === void 0 ? {} : { unit: r.unit }
+  };
+  return e.normalization === void 0 ? s : { ...s, normalization: e.normalization };
+}
+class mo extends Se {
+  /** What the last run published, kept so a caller holding the algorithm can read the result. */
+  #e;
+  /**
+   * Fill in what the caller did not pass, and refuse what this algorithm does not declare.
+   *
+   * ONE DECLARATION, NOT TWO. `descriptor.options` is the only list a declared algorithm
+   * writes, and this is what makes that true at the point the values reach the running code:
+   * the same descriptors the catalogue hands a picker are what the caller's values are checked
+   * against. The older `static optionsSchema` remains the answer for a class that declares no
+   * descriptor, which is every algorithm the element itself ships.
+   *
+   * It also fixes the failure vocabulary on the way in. The older schema throws an uncoded
+   * `Error` for a bad value and SILENTLY DROPS a name it does not know, where the run path
+   * refuses the same name with `E_UNKNOWN_OPTION` -- so the same mistake produced three
+   * different outcomes depending on which door the caller came through.
+   * @param options - What the caller asked for.
+   * @returns Every declared option, with the caller's values where they were given and the
+   *   declared defaults everywhere else.
+   * @throws A `GraphtyError` with `E_UNKNOWN_OPTION` for a name this algorithm does not
+   *   declare, or `E_OPTION_RANGE` for a value it would not accept.
+   */
+  resolveOptions(t) {
+    const { descriptor: n } = this.constructor;
+    return n === void 0 ? super.resolveOptions(t) : en(n.options, t ?? {}, {
+      kind: "algorithm",
+      id: n.key
+    });
+  }
+  /**
+   * What the last run published.
+   *
+   * THE REPLACEMENT FOR `algorithmResults`. The 1.x entry point used to scatter its numbers onto
+   * the render objects under names it chose for itself, and the only way back to them was to
+   * walk the graph. It returns a result object now, and this is where the 1.x `run()` leaves it,
+   * so the old call shape still has somewhere to read from.
+   * @returns The result, or undefined when nothing has run or there was nothing to compute.
+   */
+  get result() {
+    return this.#e;
+  }
+  /**
+   * Run the algorithm and publish what it produced on the 1.x result paths.
+   *
+   * The 1.x entry point: it returns nothing, and it publishes under the algorithm's own type
+   * rather than under a run id, because there is no run behind it. Whoever wants the result
+   * calls {@link DeclaredAlgorithm.computeRun}, which is the same work with a run in front of
+   * it.
+   * @returns A promise that settles when the result has been published.
+   */
+  async run() {
+    await this.computeRun(rs(), this.type);
+  }
+  /**
+   * Compute on behalf of a run, and hand the result back.
+   *
+   * The run machinery's entry point, which is {@link DeclaredAlgorithm.computeRun} under the
+   * name every algorithm answers to.
+   * @param context - A signal, a progress channel and a yield.
+   * @param runId - The id the result is published under.
+   * @param fields - The catalogue's descriptors for this algorithm's fields.
+   * @returns The result, or undefined when there was nothing to compute.
+   * @throws Whatever the context's signal throws once the run has been cancelled.
+   */
+  publishResult(t, n, r) {
+    return this.computeRun(t, n, r);
+  }
+  /**
+   * Compute this algorithm's result, publish it under a run id, and project the 1.x view of it.
+   *
+   * This is what the run executor calls. The catalogue's own field descriptors are passed in
+   * because the catalogue states what a reader sees a field called and cannot be imported here
+   * without a cycle -- it reads these classes to publish their options.
+   * @param context - What the element gave the run: a signal, a progress channel and a yield.
+   *   The graph the run computes over is bound here, as the context's `input`.
+   * @param runId - The id the result is published under, which is the `<runId>` in
+   *   `results.<runId>`.
+   * @param declared - The catalogue's descriptors for this algorithm's fields, when the caller
+   *   holds them.
+   * @returns The result, or undefined when there was nothing to compute.
+   * @throws Whatever the context's signal throws once the run has been cancelled, which is a
+   *   `DOMException` named `AbortError`.
+   */
+  async computeRun(t, n, r) {
+    const s = Date.now(), o = {
+      signal: t.signal,
+      report: (f) => {
+        t.report(f);
+      },
+      yieldNow: () => t.yieldNow(),
+      input: (f, l) => this.input(f, l)
+    }, i = await this.compute(o);
+    if (i === null)
+      return;
+    const a = this.input("declared"), c = es(this.graph), u = Kr(
+      Qr(this, {
+        ...c === void 0 ? {} : { labelOf: c },
+        runId: n,
+        shape: i.shape,
+        fields: i.fields.map((f) => ss(f, n, r)),
+        measured: { nodes: a.nodeCount, edges: a.edgeCount },
+        graph: i.graph,
+        nodes: i.nodes,
+        edges: i.edges,
+        caveats: i.caveats,
+        durationMs: Date.now() - s
+      })
+    );
+    return this.#e = u, u;
+  }
+}
+function yo(e, t = "number") {
+  return [
+    { name: "value", kind: e, type: t },
+    { name: "rank", kind: e, type: "integer" },
+    { name: "percentile", kind: e, type: "number" },
+    { name: "min", kind: "graph", type: "number" },
+    { name: "max", kind: "graph", type: "number" },
+    { name: "median", kind: "graph", type: "number" },
+    { name: "mean", kind: "graph", type: "number" },
+    { name: "measured", kind: "graph", type: "integer" },
+    { name: "normalization", kind: "graph", type: "string" },
+    { name: "tiedAtMin", kind: "graph", type: "integer" }
+  ];
+}
+const ht = [
+  { name: "group", kind: "node", type: "integer" },
+  { name: "groupSize", kind: "node", type: "integer" },
+  { name: "groupCount", kind: "graph", type: "integer" },
+  { name: "sizes", kind: "graph", type: "table" }
+];
+function bo(e) {
+  return e ? [...ht, { name: "modularity", kind: "graph", type: "number" }] : ht;
+}
+const wo = [
+  { name: "level", kind: "node", type: "integer" },
+  { name: "levelSize", kind: "node", type: "integer" },
+  { name: "levelCount", kind: "graph", type: "integer" },
+  { name: "sizes", kind: "graph", type: "table" }
+], vo = [
+  { name: "onPath", kind: "node", type: "boolean" },
+  { name: "order", kind: "node", type: "integer" },
+  { name: "onPath", kind: "edge", type: "boolean" },
+  { name: "length", kind: "graph", type: "integer" },
+  { name: "cost", kind: "graph", type: "number" },
+  { name: "hops", kind: "graph", type: "integer" }
+];
+function Oo(e, t) {
+  return [
+    { name: "in", kind: e, type: "boolean" },
+    { name: "count", kind: "graph", type: "integer" },
+    { ...t, kind: "graph" }
+  ];
+}
+const os = `${Ie}.${vr}`;
+function N(e) {
+  return { ...e, path: `${os}.${e.name}` };
+}
+function ko(e) {
+  return [
+    N({
+      name: "value",
+      plainName: e.plainName,
+      technicalName: e.technicalName,
+      kind: "node",
+      type: e.type ?? "number",
+      ...e.unit === void 0 ? {} : { unit: e.unit }
+    }),
+    N({ name: "rank", plainName: "Rank", technicalName: "rank", kind: "node", type: "integer" }),
+    N({
+      name: "percentile",
+      plainName: "Percentile",
+      technicalName: "percentile",
+      kind: "node",
+      type: "number"
+    }),
+    N({ name: "min", plainName: "Lowest", technicalName: "min", kind: "graph", type: "number" }),
+    N({ name: "max", plainName: "Highest", technicalName: "max", kind: "graph", type: "number" }),
+    N({ name: "median", plainName: "Middle", technicalName: "median", kind: "graph", type: "number" }),
+    N({ name: "mean", plainName: "Average", technicalName: "mean", kind: "graph", type: "number" }),
+    N({
+      name: "measured",
+      plainName: "Measured",
+      technicalName: "measured",
+      kind: "graph",
+      type: "integer"
+    }),
+    N({
+      name: "normalization",
+      plainName: "Normalization",
+      technicalName: "normalization",
+      kind: "graph",
+      type: "string"
+    }),
+    N({
+      name: "tiedAtMin",
+      plainName: "Tied at the lowest value",
+      technicalName: "tiedAtMin",
+      kind: "graph",
+      type: "integer"
+    })
+  ];
+}
+const is = 12;
+function Ao(e, t = {}) {
+  return (as(e) ? cs(e) : us(e)).map((r) => {
+    const s = { ...r.meta, ...t.meta?.[r.name] }, o = r.node === null ? fs(r.name, s, r.failure ?? "the schema could not be converted") : ls(r.name, r.node, s), i = t.overrides?.[r.name];
+    return i === void 0 ? o : { ...o, ...i };
+  });
+}
+function as(e) {
+  return typeof e != "object" || e === null ? !1 : "_zod" in e || "_def" in e;
+}
+function cs(e) {
+  const t = Wt(e);
+  if (t === null)
+    return [];
+  const { properties: n } = t;
+  return n === void 0 ? [] : Object.entries(n).map(([r, s]) => ({ name: r, node: Yt(s, t) }));
+}
+function us(e) {
+  const t = Object.entries(e), n = {};
+  for (const [o, i] of t)
+    n[o] = i.schema;
+  const r = ds(n), s = r?.properties;
+  return t.map(([o, i]) => {
+    const a = s?.[o];
+    return r === null || a === void 0 ? {
+      name: o,
+      node: null,
+      failure: "the schema could not be converted to JSON Schema",
+      meta: i.meta
+    } : { name: o, node: Yt(a, r), meta: i.meta };
+  });
+}
+function Wt(e) {
+  try {
+    return bt.toJSONSchema(e, { io: "input", unrepresentable: "any" });
+  } catch {
+    return null;
+  }
+}
+function ds(e) {
+  try {
+    return Wt(bt.object(e));
+  } catch {
+    return null;
+  }
+}
+const gt = "#/$defs/";
+function Yt(e, t) {
+  const n = e.$ref;
+  if (n === void 0 || !n.startsWith(gt))
+    return e;
+  const r = n.slice(gt.length).replaceAll("~1", "/").replaceAll("~0", "~");
+  return t.$defs?.[r] ?? e;
+}
+function ls(e, t, n) {
+  const r = qt(t, 0), s = ps(r), o = {
+    name: e,
+    plainName: n.label ?? Ue(e),
+    technicalName: e,
+    type: s.type
+  }, i = n.description ?? t.description ?? s.node?.description;
+  i !== void 0 && (o.description = i), "default" in t && (o.default = t.default);
+  const a = s.node;
+  if (a !== void 0 && (s.type === "number" || s.type === "integer")) {
+    const u = mt(a.minimum ?? a.exclusiveMinimum), f = mt(a.maximum ?? a.exclusiveMaximum);
+    u !== void 0 && (o.min = u), f !== void 0 && (o.max = f);
+  }
+  const c = n.step ?? a?.multipleOf;
+  return c !== void 0 && (o.step = c), s.values !== void 0 && (o.values = s.values), n.group !== void 0 && (o.group = n.group), n.advanced !== void 0 && (o.advanced = n.advanced), s.unsupportedReason !== void 0 && (o.unsupportedReason = s.unsupportedReason), o;
+}
+function fs(e, t, n) {
+  const r = {
+    name: e,
+    plainName: t.label ?? Ue(e),
+    technicalName: e,
+    type: "unknown",
+    unsupportedReason: n
+  };
+  return t.description !== void 0 && (r.description = t.description), t.step !== void 0 && (r.step = t.step), t.group !== void 0 && (r.group = t.group), t.advanced !== void 0 && (r.advanced = t.advanced), r;
+}
+function qt(e, t) {
+  if (t >= is)
+    return { arms: [], nullable: !1, unresolvedRef: !0 };
+  if (e.$ref !== void 0)
+    return { arms: [], nullable: !1, unresolvedRef: !0 };
+  const n = e.anyOf ?? e.oneOf;
+  if (n === void 0)
+    return e.type === "null" ? { arms: [], nullable: !0, unresolvedRef: !1 } : { arms: [e], nullable: !1, unresolvedRef: !1 };
+  const r = { arms: [], nullable: !1, unresolvedRef: !1 };
+  for (const s of n) {
+    const o = qt(s, t + 1);
+    r.arms.push(...o.arms), r.nullable = r.nullable || o.nullable, r.unresolvedRef = r.unresolvedRef || o.unresolvedRef;
+  }
+  return r;
+}
+function ps(e) {
+  if (e.arms.length === 0)
+    return e.unresolvedRef ? {
+      type: "unknown",
+      unsupportedReason: "the schema is recursive, so it has no single value type"
+    } : {
+      type: "unknown",
+      unsupportedReason: e.nullable ? "the only value the schema accepts is null" : "the schema declares no value type"
+    };
+  const t = gs(e.arms);
+  if (t !== void 0)
+    return { type: "enum", node: e.arms[0], values: t };
+  if (e.arms.length === 1)
+    return hs(e.arms[0]);
+  const n = e.arms.map((r) => Kt(r));
+  return n.length === 2 && n.includes("string") && n.includes("number") ? { type: "node-id" } : {
+    type: "unknown",
+    unsupportedReason: `the schema is a union of ${n.join(" and ")}, which has no single control`
+  };
+}
+function hs(e) {
+  switch (Kt(e)) {
+    case "integer":
+      return { type: "integer", node: e };
+    case "number":
+      return { type: "number", node: e };
+    case "boolean":
+      return { type: "boolean", node: e };
+    case "string":
+      return { type: "string", node: e };
+    case "array":
+      return {
+        type: "unknown",
+        node: e,
+        unsupportedReason: "an array option has no descriptor type; give it one with an override"
+      };
+    case "object":
+      return {
+        type: "unknown",
+        node: e,
+        unsupportedReason: "an object or record option has no descriptor type; give it one with an override"
+      };
+    default:
+      return {
+        type: "unknown",
+        node: e,
+        unsupportedReason: "the Zod construct has no JSON Schema type, so its values cannot be classified"
+      };
+  }
+}
+function gs(e) {
+  const t = [];
+  for (const r of e)
+    if (r.enum !== void 0)
+      t.push(...r.enum);
+    else if ("const" in r)
+      t.push(r.const);
+    else
+      return;
+  if (t.length === 0)
+    return;
+  const n = [];
+  for (const r of t) {
+    if (typeof r != "string" && typeof r != "number" && typeof r != "boolean")
+      return;
+    const s = String(r);
+    n.push({ value: s, label: Ue(s) });
+  }
+  return n;
+}
+function Kt(e) {
+  const { type: t } = e;
+  return typeof t == "string" ? t : Array.isArray(t) && t.length > 0 ? t[0] : "none";
+}
+function mt(e) {
+  if (!(e === Number.MAX_SAFE_INTEGER || e === -Number.MAX_SAFE_INTEGER))
+    return e;
+}
+function Ue(e) {
+  const t = e.replace(/([a-z0-9])([A-Z])/gu, "$1 $2").replace(/[_-]+/gu, " ").trim();
+  return t === "" ? e : t.split(/\s+/u).map((n) => n.charAt(0).toUpperCase() + n.slice(1)).join(" ");
+}
+export {
+  me as $,
+  Se as A,
+  xs as B,
+  an as C,
+  Ms as D,
+  Es as E,
+  At as F,
+  pn as G,
+  un as H,
+  wt as I,
+  Ss as J,
+  Ys as K,
+  wo as L,
+  qs as M,
+  es as N,
+  O,
+  vo as P,
+  Kr as Q,
+  io as R,
+  Qr as S,
+  Cs as T,
+  $s as U,
+  Ts as V,
+  _s as W,
+  z as X,
+  ns as Y,
+  Fr as Z,
+  De as _,
+  mo as a,
+  Ds as a0,
+  ze as a1,
+  Mt as a2,
+  we as a3,
+  Ps as a4,
+  Hs as a5,
+  Ls as a6,
+  js as a7,
+  In as a8,
+  Us as a9,
+  uo as aA,
+  Qs as aB,
+  po as aC,
+  Zs as aD,
+  Bs as aE,
+  Ks as aF,
+  ve as aa,
+  Ct as ab,
+  On as ac,
+  vn as ad,
+  Ws as ae,
+  Js as af,
+  B as ag,
+  Gs as ah,
+  Vs as ai,
+  Sn as aj,
+  An as ak,
+  Ht as al,
+  fo as am,
+  oo as an,
+  eo as ao,
+  Re as ap,
+  kn as aq,
+  Lt as ar,
+  Nr as as,
+  so as at,
+  ro as au,
+  no as av,
+  to as aw,
+  Or as ax,
+  ao as ay,
+  lo as az,
+  zs as b,
+  co as c,
+  Ns as d,
+  bo as e,
+  ho as f,
+  Xs as g,
+  go as h,
+  yo as i,
+  Fs as j,
+  As as k,
+  Bn as l,
+  N as m,
+  ko as n,
+  Ao as o,
+  on as p,
+  Is as q,
+  ks as r,
+  Oo as s,
+  Ie as t,
+  je as u,
+  Un as v,
+  rr as w,
+  Rs as x,
+  br as y,
+  Y as z
+};