@graphty/graphty-element 2.6.1 → 3.0.0

package/dist/chunks/optionsFromZod-CKMYSwTz.js

@@ -1,3636 +0,0 @@
-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
-};