@graphty/graphty-element 2.5.2 → 2.6.0

package/dist/chunks/optionsFromZod-B9RncoTX.js

@@ -1,2578 +0,0 @@
-import { c as he, G as y, S as Ie } from "./pluginRegistry-Bs8bEkz9.js";
-import { K as Te, f as Me } from "./types-C_c53VgR.js";
-import { b as _e } from "./GraphtyLogger-DOTwCiMR.js";
-import { Graph as ze, accelerated as X } from "@graphty/algorithms";
-import { INVALID_INDEX as L } from "@graphty/graph-format";
-import { z as me } from "zod/v4";
-const _ = he({
-  kind: "camera",
-  idOf: (e) => e.descriptor.id,
-  descriptorOf: (e) => e.descriptor,
-  implementationOf: (e) => e.compute,
-  builtInIds: () => Te
-});
-function wn(e, t) {
-  const n = e.descriptor;
-  if (n === void 0 || typeof n != "object")
-    throw new y({
-      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 y({
-      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 y({
-      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 y({
-      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" }
-    });
-  _.register(e, t);
-}
-function vn() {
-  return _.descriptors();
-}
-function On(e) {
-  return _.byId(e);
-}
-function kn() {
-  _.clearForTesting();
-}
-const Ce = ["forceAtlas2", "fruchtermanReingold", "springElectrical", "release"], xe = [
-  "pageRank",
-  "sssp",
-  "breadthFirstSearch",
-  "connectedComponents",
-  "weaklyConnectedComponents",
-  "minimumSpanningTree"
-];
-function Nn(e) {
-  const t = {
-    kind: e.backend
-  };
-  for (const n of Ce) {
-    const r = e[n];
-    typeof r == "function" && (t[n] = r.bind(e));
-  }
-  return t;
-}
-function je(e) {
-  const t = {
-    kind: e.backend
-  };
-  for (const n of xe) {
-    const r = e[n];
-    typeof r == "function" && (t[n] = r.bind(e));
-  }
-  return t;
-}
-const Pe = ["auto", "off", "required"], Sn = "auto";
-function An(e) {
-  return typeof e == "string" && Pe.includes(e);
-}
-const Le = "f64", $n = "f32", Rn = "acceleration.minNodes", En = 0, Fn = "RTX 4070 SUPER, headless Chromium, 2026-09-25", In = Object.freeze({
-  breadthFirstSearch: 3e5,
-  sssp: 3e5,
-  pageRank: 5e3,
-  connectedComponents: 5e4
-}), z = he({
-  kind: "algorithm",
-  idOf: (e) => e.descriptor.key,
-  descriptorOf: (e) => e.descriptor,
-  implementationOf: (e) => e.descriptor,
-  builtInIds: () => Me
-});
-function De(e, t) {
-  if (e.descriptor.key !== e.type)
-    throw new y({
-      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
-      }
-    });
-  z.register(e, t);
-}
-function Tn() {
-  return z.descriptors();
-}
-function Mn(e) {
-  return z.byId(e);
-}
-function _n() {
-  z.clearForTesting();
-}
-class b 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 Ge(e, t, n) {
-  if (t == null) {
-    if (n.required)
-      throw new b(e, "is required but was not provided");
-    return;
-  }
-  switch (n.type) {
-    case "number":
-      Q(e, t, n, !1);
-      break;
-    case "integer":
-      Q(e, t, n, !0);
-      break;
-    case "boolean":
-      if (typeof t != "boolean")
-        throw new b(e, `must be a boolean, got ${typeof t}`);
-      break;
-    case "string":
-      if (typeof t != "string")
-        throw new b(e, `must be a string, got ${typeof t}`);
-      break;
-    case "select":
-      Ue(e, t, n);
-      break;
-    case "nodeId":
-      if (typeof t != "string" && typeof t != "number")
-        throw new b(e, `must be a string or number (node ID), got ${typeof t}`);
-      break;
-    default:
-      throw new b(e, `has unknown type '${n.type}'`);
-  }
-}
-function Q(e, t, n, r) {
-  if (typeof t != "number")
-    throw new b(e, `must be a number, got ${typeof t}`);
-  if (Number.isNaN(t))
-    throw new b(e, "must not be NaN");
-  if (!Number.isFinite(t))
-    throw new b(e, "must be finite");
-  if (r && !Number.isInteger(t))
-    throw new b(e, `must be an integer, got ${t}`);
-  if (n.min !== void 0 && t < n.min)
-    throw new b(e, `must be >= ${n.min}, got ${t}`);
-  if (n.max !== void 0 && t > n.max)
-    throw new b(e, `must be <= ${n.max}, got ${t}`);
-}
-function Ue(e, t, n) {
-  if (!n.options || n.options.length === 0)
-    throw new b(e, "is a select type but has no options defined");
-  if (!n.options.map((i) => i.value).includes(t)) {
-    const i = n.options.map((s) => `'${String(s.value)}'`).join(", ");
-    throw new b(e, `must be one of [${i}], got '${String(t)}'`);
-  }
-}
-function He(e, t) {
-  const n = {};
-  for (const [r, i] of Object.entries(e)) {
-    const o = t?.[r] ?? i.default;
-    Ge(r, o, i), n[r] = o;
-  }
-  return n;
-}
-function zn(e) {
-  return e;
-}
-function Be(e, t) {
-  const n = e.getSnapshot(), r = t === "directed" ? n : e.undirected(n).snapshot, i = r.flags.multigraph ? r.simplified({ weights: "sum" }).snapshot : r;
-  return Ve(i, t);
-}
-function Cn(e) {
-  const t = e.getSnapshot();
-  return t.flags.multigraph ? t.edgeCount - t.simplified({ weights: "sum" }).snapshot.edgeCount : 0;
-}
-function Ve(e, t) {
-  const n = new ze({
-    directed: t !== "undirected"
-  }), { ids: r } = e;
-  for (let a = 0; a < e.nodeCount; a++)
-    n.addNode(r.idOf(a));
-  const { src: i, dst: s, weights: o } = e.edgeList();
-  for (let a = 0; a < e.edgeCount; a++) {
-    const u = r.idOf(i[a]), c = r.idOf(s[a]), h = o === null ? 1 : o[a];
-    n.addEdge(u, c, h);
-  }
-  return n;
-}
-const E = new Ie("algorithm");
-function Je(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 i = e[r];
-    n[r] = i === L ? L : t[i];
-  }
-  return n;
-}
-const Z = class Z {
-  /**
-   * 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 Be(this.graph.getDataManager(), t);
-  }
-  /**
-   * 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 r = this.graph.getDataManager(), i = r.getSnapshot(), s = n === "undirected" ? r.undirected(i) : null, o = s === null ? i : s.snapshot, a = o.flags.multigraph ? o.simplified({ weights: "sum" }) : null, u = a === null ? o : a.snapshot, c = this.graph.acceleration, h = { capability: t, nodeCount: u.nodeCount };
-    return {
-      snapshot: u,
-      edgeRemap: Je(s?.edgeRemap ?? null, a?.edgeRemap ?? null),
-      run: async (p) => {
-        const l = await c.run(
-          h,
-          (d) => p(X(je(d)), u)
-        );
-        return l.accelerated ? { value: l.value, precision: l.precision } : { value: await p(X(null), u), precision: Le };
-      }
-    };
-  }
-  /**
-   * 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 i = t.ids.indexOf(r);
-    if (i === L)
-      throw new y({
-        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 i;
-  }
-  /**
-   * 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 ? {} : He(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 y({
-        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), i = String(n.namespace), { descriptor: s, cost: o, costUnits: a, version: u } = n;
-    return s !== void 0 && De({
-      descriptor: s,
-      namespace: i,
-      type: r,
-      ...o === void 0 ? {} : { cost: o },
-      ...a === void 0 ? {} : { costUnits: a },
-      ...u === void 0 ? {} : { version: u }
-    }), E.set(`${i}:${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, i) {
-    const s = E.get(`${n}:${r}`);
-    return s ? new s(t, i) : 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 E.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 E.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();
-  }
-};
-Z.optionsSchema = {};
-let D = Z;
-const ee = 3, qe = 0.1;
-function m(e, t) {
-  return Number.isInteger(e) ? e.toLocaleString(t) : Number(e.toFixed(ee)).toLocaleString(t, { maximumFractionDigits: ee });
-}
-function Ye(e, t, n) {
-  const r = e.fields.find((i) => i.name === t);
-  return r === void 0 ? t : n === "technical" ? r.technicalName : r.plainName.toLowerCase();
-}
-function C(e, t, n) {
-  const r = e.fields.find((i) => i.name === t)?.unit;
-  return r === void 0 ? "" : n === 1 && r.endsWith("s") ? ` ${r.slice(0, -1)}` : ` ${r}`;
-}
-function R(e, t) {
-  const n = e.graph[t];
-  return typeof n == "number" && Number.isFinite(n) ? n : void 0;
-}
-function We(e) {
-  return e[0];
-}
-function Ke(e, t, n) {
-  const { locale: r, audience: i } = n, s = Ye(e, "value", i), o = We(t.top);
-  if (o === void 0 || t.median === null)
-    return `Nothing was measured, so there is no ${s} to report.`;
-  const a = [
-    `${o.label} has the highest ${s}, at ${m(o.value, r)}${C(e, "value", o.value)}.`,
-    `The typical element sits at ${m(t.median, r)}${C(e, "value", t.median)}.`
-  ];
-  return t.measured > 0 && t.tiedAtMin / t.measured >= qe && t.min !== null && a.push(
-    `${m(t.tiedAtMin, r)} of ${m(t.measured, r)} sit at the lowest value, ${m(t.min, r)}${C(e, "value", t.min)}.`
-  ), t.count > t.measured && a.push(`${m(t.count - t.measured, r)} were not measured.`), a.join(" ");
-}
-function Ze(e, t, n) {
-  const { locale: r } = n, i = t.groups ?? [];
-  if (i.length === 0)
-    return "Nothing was grouped, so there are no groups to report.";
-  const s = i[0], o = [
-    `${m(i.length, r)} ${i.length === 1 ? "group" : "groups"} were found,`,
-    `the largest holding ${m(s.size, r)} of ${m(t.measured, r)}.`
-  ], a = R(e, "modularity");
-  return a !== void 0 && o.push(`Modularity is ${m(a, r)}.`), o.join(" ");
-}
-function Xe(e, t) {
-  const { locale: n } = t, r = R(e, "hops"), i = R(e, "cost");
-  if (r === void 0 && i === void 0)
-    return "No route was found.";
-  const s = [];
-  return r !== void 0 && s.push(`The route runs ${m(r, n)} ${r === 1 ? "hop" : "hops"}.`), i !== void 0 && s.push(`Its total cost is ${m(i, n)}.`), s.join(" ");
-}
-function Qe(e, t, n) {
-  const { locale: r } = n, i = R(e, "count") ?? t.measured, s = e.shape === "edge-set" ? "edge" : "node";
-  return i === 0 ? `No ${s}s were selected.` : `${m(i, r)} ${i === 1 ? s : `${s}s`} were selected.`;
-}
-function et(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 tt(e, t) {
-  const n = R(e, "steps");
-  return n === void 0 || n === 0 ? "The series is empty." : `The series covers ${m(n, t.locale)} ${n === 1 ? "step" : "steps"}.`;
-}
-function te(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 nt(e, t) {
-  const n = e.summary(), { shape: r } = e;
-  switch (r) {
-    case "node-metric":
-    case "edge-metric":
-      return Ke(e, n, t);
-    case "community":
-    case "layered-grouping":
-    case "category-table":
-      return Ze(e, n, t);
-    case "path":
-      return Xe(e, t);
-    case "node-set":
-    case "edge-set":
-      return Qe(e, n, t);
-    case "pair-list":
-      return et(e, t);
-    case "temporal":
-      return tt(e, t);
-    case "fact":
-      return te(n, t);
-    default:
-      return te(n, t);
-  }
-}
-function xn(e, t) {
-  const n = t === "node", r = n ? e.nodeValue : e.edgeValue, i = n ? e.nodeHas : e.edgeHas, s = n ? e.nodeIdOf : e.edgeIdOf;
-  return {
-    value: r,
-    has: i ?? ((o, a) => rt(r(o, a))),
-    idOf: s ?? null
-  };
-}
-function rt(e) {
-  return e != null;
-}
-function I(e) {
-  return e == null || e === !1 || e === "" ? !1 : Array.isArray(e) ? e.length > 0 : typeof e == "object" ? Object.keys(e).length > 0 : !0;
-}
-function G(e, t) {
-  if (e === t)
-    return !0;
-  if (Array.isArray(e) && Array.isArray(t))
-    return e.length === t.length && e.every((n, r) => G(n, t[r]));
-  if (ne(e) && ne(t)) {
-    const n = Object.keys(e);
-    return n.length === Object.keys(t).length && n.every((r) => G(e[r], t[r]));
-  }
-  return !1;
-}
-function ne(e) {
-  return typeof e == "object" && e !== null && !Array.isArray(e);
-}
-function f(e, t, n, r = {}) {
-  return new y({
-    code: "E_BAD_SELECTOR",
-    message: `${e} (at character ${String(n)} of ${JSON.stringify(t)})`,
-    source: "style",
-    details: { ...r, position: n, where: t }
-  });
-}
-const it = 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"
-}), st = ["&&", "||", "==", "!=", "<=", ">=", "!", "<", ">", ".", "(", ")"];
-function fe(e) {
-  return /[A-Za-z_]/.test(e);
-}
-function ge(e) {
-  return /[A-Za-z0-9_]/.test(e);
-}
-function x(e, t, n) {
-  for (let r = t + 1; r < e.length; r++) {
-    if (e[r] === "\\") {
-      r++;
-      continue;
-    }
-    if (e[r] === n)
-      return r;
-  }
-  throw f(`A ${n} is opened and never closed`, e, t, { delimiter: n });
-}
-function ot(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 at(e, t, n) {
-  const r = n.replace(/\\`/g, "`");
-  try {
-    return JSON.parse(r);
-  } catch {
-    throw f(
-      `A literal between backticks must be JSON, so a bare word needs quotes: write \`"${r}"\` rather than \`${r}\``,
-      e,
-      t,
-      { literal: r }
-    );
-  }
-}
-function ct(e, t, n) {
-  try {
-    const r = JSON.parse(n);
-    if (typeof r == "string")
-      return r;
-  } catch {
-  }
-  throw f(
-    `A quoted attribute name follows JSON's rules for a string, and ${n} does not`,
-    e,
-    t,
-    { name: n }
-  );
-}
-function ut(e) {
-  const t = [];
-  let n = 0;
-  for (; n < e.length; ) {
-    const r = e.charAt(n);
-    if (/\s/.test(r)) {
-      n++;
-      continue;
-    }
-    const i = it[r];
-    if (i !== void 0)
-      throw f(`A selector does not support ${i}`, e, n, { construct: i });
-    if (r === "|" && e.charAt(n + 1) !== "|")
-      throw f("A selector does not support pipe expressions", e, n, { construct: "pipe expressions" });
-    if (r === "&" && e.charAt(n + 1) !== "&")
-      throw f("A selector does not support expression references", e, n, {
-        construct: "expression references"
-      });
-    const s = st.find((o) => e.startsWith(o, n));
-    if (s !== void 0) {
-      t.push({ kind: "operator", text: s, at: n }), n += s.length;
-      continue;
-    }
-    if (r === "`") {
-      const o = x(e, n, "`");
-      t.push({ kind: "literal", text: "", value: at(e, n, e.slice(n + 1, o)), at: n }), n = o + 1;
-      continue;
-    }
-    if (r === "'") {
-      const o = x(e, n, "'");
-      t.push({ kind: "literal", text: "", value: ot(e.slice(n + 1, o)), at: n }), n = o + 1;
-      continue;
-    }
-    if (r === '"') {
-      const o = x(e, n, '"');
-      t.push({ kind: "identifier", text: ct(e, n, e.slice(n, o + 1)), at: n }), n = o + 1;
-      continue;
-    }
-    if (fe(r)) {
-      let o = n + 1;
-      for (; o < e.length && ge(e.charAt(o)); )
-        o++;
-      t.push({ kind: "identifier", text: e.slice(n, o), at: n }), n = o;
-      continue;
-    }
-    throw /[0-9-]/.test(r) ? f(
-      "A number in a selector goes between backticks, so write `5` rather than 5",
-      e,
-      n,
-      { character: r }
-    ) : f(`${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 lt = Object.freeze({
-  "!=": "!=",
-  "<": "<",
-  "<=": "<=",
-  "==": "==",
-  ">": ">",
-  ">=": ">="
-});
-function N(e) {
-  return e.tokens[e.index];
-}
-function S(e, t) {
-  const n = N(e);
-  return n.kind === "operator" && n.text === t;
-}
-function dt(e) {
-  const t = N(e), n = [];
-  for (; ; ) {
-    const r = N(e);
-    if (r.kind !== "identifier")
-      throw f("A `.` must be followed by an attribute name", e.where, r.at);
-    if (r.text.includes("."))
-      throw f(
-        `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++, S(e, "("))
-      throw f(
-        `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), !S(e, "."))
-      return { kind: "path", path: n.join("."), at: t.at };
-    e.index++;
-  }
-}
-function pt(e) {
-  const t = N(e);
-  if (t.kind === "literal")
-    return e.index++, { kind: "literal", value: t.value };
-  if (t.kind === "identifier")
-    return dt(e);
-  if (S(e, "(")) {
-    e.index++;
-    const n = ye(e);
-    if (!S(e, ")"))
-      throw f("A `(` is opened and never closed", e.where, t.at);
-    return e.index++, { kind: "group", inner: n };
-  }
-  throw f(
-    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 U(e) {
-  if (!S(e, "!"))
-    return pt(e);
-  const t = N(e);
-  e.index++;
-  const n = U(e);
-  if (n.kind === "path" && n.path.includes("."))
-    throw f(
-      `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 re(e) {
-  const t = U(e), n = N(e), r = n.kind === "operator" ? lt[n.text] : void 0;
-  return r === void 0 ? t : (e.index++, { kind: "compare", operator: r, left: t, right: U(e) });
-}
-function ie(e) {
-  let t = re(e);
-  for (; S(e, "&&"); )
-    e.index++, t = { kind: "and", left: t, right: re(e) };
-  return t;
-}
-function ye(e) {
-  let t = ie(e);
-  for (; S(e, "||"); )
-    e.index++, t = { kind: "or", left: t, right: ie(e) };
-  return t;
-}
-function ht(e) {
-  const t = { where: e, tokens: ut(e), index: 0 }, n = ye(t), r = N(t);
-  if (r.kind !== "end")
-    throw f(
-      `${JSON.stringify(r.text)} is left over at the end of the selector`,
-      e,
-      r.at
-    );
-  return n;
-}
-function $(e, t) {
-  switch (e.kind) {
-    case "path":
-      t.includes(e.path) || t.push(e.path);
-      return;
-    case "group":
-      $(e.inner, t);
-      return;
-    case "not":
-      $(e.operand, t);
-      return;
-    case "and":
-    case "or":
-    case "compare":
-      $(e.left, t), $(e.right, t);
-      return;
-    default:
-      return;
-  }
-}
-function w(e, t) {
-  switch (e.kind) {
-    case "path": {
-      const { path: n } = e, { value: r } = t;
-      return (i) => {
-        const s = r(i, n);
-        return s === void 0 ? null : s;
-      };
-    }
-    case "literal": {
-      const { value: n } = e;
-      return () => n;
-    }
-    case "group":
-      return w(e.inner, t);
-    case "not": {
-      const n = w(e.operand, t);
-      return (r) => !I(n(r));
-    }
-    case "and": {
-      const n = w(e.left, t), r = w(e.right, t);
-      return (i) => {
-        const s = n(i);
-        return I(s) ? r(i) : s;
-      };
-    }
-    case "or": {
-      const n = w(e.left, t), r = w(e.right, t);
-      return (i) => {
-        const s = n(i);
-        return I(s) ? s : r(i);
-      };
-    }
-    default:
-      return gt(e.operator, e.left, e.right, t);
-  }
-}
-const mt = Object.freeze({
-  "<": (e, t) => e < t,
-  "<=": (e, t) => e <= t,
-  ">": (e, t) => e > t,
-  ">=": (e, t) => e >= t
-});
-function ft(e, t) {
-  return e.kind === "literal" ? e : t.kind === "literal" ? t : null;
-}
-function gt(e, t, n, r) {
-  if (e === "==" || e === "!=") {
-    const a = e === "==", u = t.kind === "literal", c = ft(t, n), h = u ? n : t;
-    if (c !== null && c.value === null && h.kind === "path") {
-      const { path: d } = h, { has: v } = r;
-      return (k) => v(k, d) !== a;
-    }
-    const p = w(t, r), l = w(n, r);
-    if (c !== null && c.value !== null && typeof c.value != "object") {
-      const { value: d } = c, v = u ? l : p;
-      return (k) => v(k) === d === a;
-    }
-    return (d) => G(p(d), l(d)) === a;
-  }
-  const i = w(t, r), s = w(n, r), o = mt[e];
-  return (a) => {
-    const u = i(a), c = s(a);
-    return typeof u == "number" && typeof c == "number" ? o(u, c) : null;
-  };
-}
-function A(e, t) {
-  switch (e.kind) {
-    case "compare":
-    case "not": {
-      const n = w(e, t);
-      return (r) => n(r) === !0;
-    }
-    case "group":
-      return A(e.inner, t);
-    case "and": {
-      const n = A(e.left, t), r = A(e.right, t);
-      return (i) => n(i) && r(i);
-    }
-    case "or": {
-      const n = A(e.left, t), r = A(e.right, t);
-      return (i) => n(i) || r(i);
-    }
-    default: {
-      const n = w(e, t);
-      return (r) => I(n(r));
-    }
-  }
-}
-function yt(e) {
-  return e.split(".").map((t) => bt(t) ? t : JSON.stringify(t)).join(".");
-}
-function bt(e) {
-  if (e === "" || !fe(e[0]))
-    return !1;
-  for (let t = 1; t < e.length; t++)
-    if (!ge(e[t]))
-      return !1;
-  return !0;
-}
-function jn(e, t) {
-  const { has: n } = e;
-  return (r) => n(r, t);
-}
-function Pn(e, t) {
-  const { idOf: n } = e;
-  if (n === null)
-    throw new y({
-      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 Ln(e, t, n) {
-  const { value: r } = e;
-  return (i) => {
-    const s = n();
-    if (s === void 0)
-      return !1;
-    const o = r(i, t);
-    return typeof o == "number" && Number.isFinite(o) && o >= s;
-  };
-}
-function Dn(e, t) {
-  const n = ht(e), r = [];
-  if ($(n, r), r.length === 0) {
-    let i = n;
-    for (; i.kind === "group"; )
-      i = i.inner;
-    const s = i.kind === "literal" && typeof i.value == "string";
-    throw f(
-      s ? "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: A(n, t) };
-}
-const H = "results", wt = "$";
-function T(e, t) {
-  return t === void 0 ? `${H}.${e}` : `${H}.${e}.${t}`;
-}
-function vt(e) {
-  return `Group ${String(e)}`;
-}
-function be(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 we = {
-  // -- 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"]
-  }
-}, Gn = Object.keys(we), J = {
-  "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 B(e) {
-  return J[e];
-}
-function Un(e) {
-  return J[e].layer === "highlight";
-}
-function Hn(e, t) {
-  const n = J[e], r = [], i = [
-    { names: n.nodeFields, kind: "node" },
-    { names: n.edgeFields, kind: "edge" },
-    { names: n.graphFields, kind: "graph" }
-  ];
-  for (const { names: s, kind: o } of i)
-    for (const a of s) {
-      const u = t.find((h) => h.name === a && h.kind === o);
-      if (u === void 0) {
-        r.push({
-          field: a,
-          kind: o,
-          reason: `shape "${e}" requires a ${o} field named "${a}"`
-        });
-        continue;
-      }
-      const c = we[a].types;
-      c.includes(u.type) || r.push({
-        field: a,
-        kind: o,
-        reason: `${o} field "${a}" is typed "${u.type}", not ${c.map((h) => `"${h}"`).join(" or ")}`
-      });
-    }
-  return n.headlineScalar && !Ot(n, t) && r.push({
-    field: null,
-    kind: "graph",
-    reason: `shape "${e}" requires one graph-level scalar of its own beside "count"`
-  }), r;
-}
-function Ot(e, t) {
-  const n = [...e.graphFields, ...e.optionalGraphFields];
-  return t.some((r) => r.kind === "graph" && !n.includes(r.name));
-}
-const kt = 3;
-function Nt(e, t) {
-  if (e === t)
-    return 0;
-  const n = new Uint32Array(t.length + 1), r = new Uint32Array(t.length + 1);
-  for (let i = 0; i <= t.length; i++)
-    n[i] = i;
-  for (let i = 1; i <= e.length; i++) {
-    r[0] = i;
-    for (let s = 1; s <= t.length; s++) {
-      const o = n[s - 1] + (e[i - 1] === t[s - 1] ? 0 : 1);
-      r[s] = Math.min(r[s - 1] + 1, n[s] + 1, o);
-    }
-    n.set(r);
-  }
-  return n[t.length];
-}
-function St(e, t, n = kt) {
-  const r = e.toLowerCase(), i = t.map((s) => ({
-    candidate: s,
-    distance: Nt(r, s.toLowerCase())
-  }));
-  return i.sort((s, o) => s.distance - o.distance || s.candidate.localeCompare(o.candidate)), Object.freeze(i.slice(0, Math.max(n, 0)).map((s) => s.candidate));
-}
-function se(e) {
-  return typeof e == "string" ? e : "runId" in e ? e.runId : e.id;
-}
-function At(e) {
-  return typeof e == "string" ? void 0 : e.shape;
-}
-function $t(e, t) {
-  return e.fields.some((n) => n.name === t) || t in e.graph;
-}
-class Rt {
-  #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 = se(t);
-    if (n !== void 0)
-      return T(r, n);
-    const i = At(t) ?? this.#e.entry(r)?.shape, s = i === void 0 ? null : B(i).primaryField;
-    return s === null ? T(r) : T(r, s);
-  }
-  /**
-   * 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 yt(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(se(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 || $t(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);
-  }
-}
-function Bn(e) {
-  return new Rt(e);
-}
-const Et = 20, j = 100, Ft = 100, It = Object.freeze([]), Tt = Object.freeze(["max", "min-max", "none"]);
-function ve(e) {
-  return typeof e == "string" && Tt.includes(e);
-}
-function Vn(e) {
-  return {
-    length: e.length,
-    get: (t) => e[t]
-  };
-}
-const Mt = Object.freeze({
-  measured: 0,
-  min: Number.NaN,
-  max: Number.NaN,
-  mean: Number.NaN,
-  median: Number.NaN,
-  tiedAtMin: 0,
-  smallestPositive: null
-});
-function Oe(e) {
-  const { length: t } = e, n = new Float64Array(t);
-  let r = 0;
-  for (let l = 0; l < t; l++) {
-    const d = e.get(l);
-    Number.isFinite(d) && (n[r] = d, r++);
-  }
-  if (r === 0)
-    return { length: t, ...Mt };
-  let i = Number.POSITIVE_INFINITY, s = Number.NEGATIVE_INFINITY, o = Number.POSITIVE_INFINITY, a = 0, u = 0;
-  for (let l = 0; l < r; l++) {
-    const d = n[l];
-    d < i && (i = d), d > s && (s = d), d > 0 && d < o && (o = d);
-    const v = d - u, k = a + v;
-    u = k - a - v, a = k;
-  }
-  const c = n.slice(0, r).sort(), h = c[Math.floor((r - 1) / 2)];
-  let p = 0;
-  for (; p < r && c[p] === i; )
-    p++;
-  return {
-    length: t,
-    measured: r,
-    min: i,
-    max: s,
-    mean: a / r,
-    median: h,
-    tiedAtMin: p,
-    smallestPositive: Number.isFinite(o) ? o : null
-  };
-}
-function ke(e) {
-  const t = Oe(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 q(e) {
-  const t = e.filter((o) => Number.isFinite(o.value)).map((o) => ({ entry: o, label: String(o.id) }));
-  t.sort((o, a) => o.entry.value !== a.entry.value ? a.entry.value - o.entry.value : o.label === a.label ? 0 : o.label < a.label ? -1 : 1);
-  const n = t.length, r = [];
-  let i = 0, s = Number.NaN;
-  for (let o = 0; o < n; o++) {
-    const { entry: a } = t[o];
-    a.value !== s && (i = o + 1, s = a.value), r.push(
-      Object.freeze({
-        id: a.id,
-        value: a.value,
-        rank: i,
-        percentile: (n - i + 1) / n
-      })
-    );
-  }
-  return Object.freeze(r);
-}
-function _t(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 i = n;
-  for (; i < e.length && e[i].value === r; )
-    i++;
-  const s = i - n, o = `${String(s)} tie at ${String(r)}, and taking them would make ${String(n + s)}, 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: s }),
-    reason: o
-  });
-}
-function zt(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 Ct(e) {
-  return e.measured === 0 || !(e.median > 0) || e.max / e.median <= Ft ? "linear" : zt(e) ? "log" : "linear";
-}
-function xt(e, t, n, r) {
-  if (!(t > e))
-    return { binCount: 1, indexOf: () => 0, rangeOf: () => [e, t] };
-  if (r) {
-    const s = t - e + 1, o = Math.ceil(s / Math.min(s, n)), a = Math.ceil(s / o);
-    return {
-      binCount: a,
-      indexOf: (u) => Math.min(Math.floor((u - e) / o), a - 1),
-      rangeOf: (u) => {
-        const c = e + u * o;
-        return [c, Math.min(c + o - 1, t)];
-      }
-    };
-  }
-  const i = (t - e) / n;
-  return {
-    binCount: n,
-    indexOf: (s) => Math.min(Math.floor((s - e) / i), n - 1),
-    rangeOf: (s) => [
-      e + s * i,
-      s === n - 1 ? t : e + (s + 1) * i
-    ]
-  };
-}
-function jt(e, t, n, r, i) {
-  const s = e > 0 ? 0 : 1, o = s === 0 ? e : n;
-  if (!(t > 0) || o === null || !(o > 0))
-    return null;
-  const a = Math.log10(o), u = Math.log10(t);
-  if (!(u > a))
-    return null;
-  const c = r - s;
-  if (c < 1)
-    return null;
-  const h = (u - a) / c;
-  return {
-    binCount: r,
-    indexOf: (p) => {
-      if (!(p > 0))
-        return 0;
-      const l = Math.floor((Math.log10(p) - a) / h);
-      return s + Math.min(Math.max(l, 0), c - 1);
-    },
-    rangeOf: (p) => {
-      if (p < s)
-        return [e, 0];
-      const l = p - s, d = l === 0 ? o : 10 ** (a + l * h), v = l === c - 1 ? t : 10 ** (a + (l + 1) * h);
-      if (!i)
-        return [d, v];
-      const k = l === 0 ? o : Math.ceil(d);
-      return [k, l === c - 1 ? t : Math.max(k, Math.ceil(v) - 1)];
-    }
-  };
-}
-function Pt(e) {
-  if (e === void 0)
-    return Et;
-  if (!Number.isInteger(e) || e < 1 || e > j)
-    throw new y({
-      code: "E_OPTION_RANGE",
-      source: "run",
-      message: `A histogram takes between 1 and ${j} bins; ${String(e)} was asked for.`,
-      details: { option: "bins", value: e, min: 1, max: j }
-    });
-  return e;
-}
-function Lt(e, t) {
-  const n = /* @__PURE__ */ new Map();
-  for (let r = 0; r < e.length; r++) {
-    const i = e.get(r);
-    if (!Number.isFinite(i))
-      continue;
-    const s = n.get(i);
-    if (s === void 0) {
-      if (n.size >= t)
-        return null;
-      n.set(i, 1);
-      continue;
-    }
-    n.set(i, s + 1);
-  }
-  return n;
-}
-function Dt(e, t) {
-  const n = Pt(t?.bins), r = t?.integerValued ?? !1, i = Oe(e), s = Ct(i), o = Lt(e, n);
-  if (o !== null) {
-    if (o.size === 0)
-      return Object.freeze({
-        bins: It,
-        // 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 p = [...o.entries()].sort((l, d) => l[0] - d[0]).map(([l, d]) => Object.freeze({ from: l, to: l, count: d }));
-    return Object.freeze({
-      bins: Object.freeze(p),
-      // 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: s,
-      binning: "per-value"
-    });
-  }
-  const u = t?.scale === "log" || t?.scale === "auto" && s === "log" ? jt(i.min, i.max, i.smallestPositive, n, r) : null, c = u ?? xt(i.min, i.max, n, r), h = new Array(c.binCount).fill(0);
-  for (let p = 0; p < e.length; p++) {
-    const l = e.get(p);
-    Number.isFinite(l) && (h[c.indexOf(l)] += 1);
-  }
-  return Object.freeze({
-    bins: Object.freeze(
-      h.map((p, l) => {
-        const [d, v] = c.rangeOf(l);
-        return Object.freeze({ from: d, to: v, count: p });
-      })
-    ),
-    // `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: u === null ? "linear" : "log",
-    suggestedScale: s,
-    binning: "banded"
-  });
-}
-const Gt = 10, Ut = 10;
-function oe(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 V(e, t) {
-  const { records: n } = e;
-  return {
-    length: n.length,
-    get: (r) => Ne(n[r][t])
-  };
-}
-function Y(e, t) {
-  return e.ids.map((n, r) => ({ id: n, value: Ne(e.records[r][t]) }));
-}
-function Ne(e) {
-  return typeof e == "number" ? e : Number.NaN;
-}
-function W(e) {
-  return typeof e == "string" || typeof e == "number";
-}
-function P(e) {
-  return e.type === "number" || e.type === "integer";
-}
-function g(e, t, n) {
-  e[t] === void 0 && (e[t] = n);
-}
-function M(e, t, n) {
-  e[t] === void 0 && (e[t] = n);
-}
-function Se(e, t) {
-  const n = /* @__PURE__ */ new Map();
-  for (const r of e.records) {
-    const i = r[t];
-    W(i) && n.set(i, (n.get(i) ?? 0) + 1);
-  }
-  return n;
-}
-function Ht(e) {
-  const t = [...e.entries()].map(([n, r]) => ({ group: n, size: r }));
-  return t.sort((n, r) => r.size - n.size || be(n.group, r.group)), Object.freeze(t.map((n) => Object.freeze(n)));
-}
-function Ae(e, t) {
-  const n = e.find((r) => r.name === t)?.normalization;
-  return ve(n) ? n : "none";
-}
-function ae(e, t, n) {
-  const { statistics: r } = ke(V(e, "value"));
-  for (const i of q(Y(e, "value"))) {
-    const s = e.index.get(i.id);
-    s !== void 0 && (M(e.records[s], "rank", i.rank), M(e.records[s], "percentile", i.percentile));
-  }
-  r.measured > 0 && (g(t, "min", r.min), g(t, "max", r.max), g(t, "median", r.median), g(t, "mean", r.mean)), g(t, "measured", r.measured), g(t, "tiedAtMin", r.tiedAtMin), g(t, "normalization", Ae(n, "value"));
-}
-function ce(e, t, n, r, i) {
-  const s = Se(e, n);
-  for (const o of e.records) {
-    const a = o[n];
-    W(a) && M(o, r, s.get(a));
-  }
-  g(t, i, s.size), g(t, "sizes", Ht(s));
-}
-function Bt(e, t) {
-  for (const r of q(Y(e, "score"))) {
-    const i = e.index.get(r.id);
-    i !== void 0 && M(e.records[i], "rank", r.rank);
-  }
-  const n = [...Se(e, "category").entries()].map(([r, i]) => ({
-    category: String(r),
-    count: i
-  }));
-  n.sort((r, i) => i.count - r.count || be(r.category, i.category)), g(t, "categories", Object.freeze(n.map((r) => Object.freeze(r))));
-}
-function F(e, t) {
-  let n = 0;
-  for (const r of e.records)
-    r[t] === !0 && n++;
-  return n;
-}
-function ue(e, t) {
-  let n = 0;
-  for (const r of e.records)
-    r[t] !== void 0 && n++;
-  return n;
-}
-function Vt(e, t, n, r, i) {
-  switch (e) {
-    case "node-metric":
-      ae(t, r, i);
-      break;
-    case "edge-metric":
-      ae(n, r, i);
-      break;
-    case "community":
-      ce(t, r, "group", "groupSize", "groupCount");
-      break;
-    case "layered-grouping":
-      ce(t, r, "level", "levelSize", "levelCount");
-      break;
-    case "category-table":
-      Bt(t, r);
-      break;
-    case "path":
-      g(r, "length", F(t, "onPath")), g(r, "hops", F(n, "onPath"));
-      break;
-    case "node-set":
-      g(r, "count", F(t, "in"));
-      break;
-    case "edge-set":
-      g(r, "count", F(n, "in"));
-      break;
-  }
-}
-function Jt(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 qt(e, t, n) {
-  if (!Array.isArray(e))
-    return;
-  const r = [];
-  for (const i of e) {
-    if (typeof i != "object" || i === null)
-      continue;
-    const s = i, o = s.group ?? s.category, a = s.size ?? s.count;
-    if (W(o) && typeof a == "number" && r.push(Object.freeze(n ? { group: o, size: a, name: vt(r.length + 1) } : { group: o, size: a })), r.length === t)
-      break;
-  }
-  return Object.freeze(r);
-}
-class Yt {
-  #e;
-  #t;
-  #n;
-  #r;
-  #i;
-  #s;
-  #o = /* @__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, i) {
-    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 = i, this.#e = n, this.#t = r, this.#n = t.caveats, this.#r = t.durationMs, this.#i = t.labelOf ?? (() => {
-    }), this.#s = t.reading ?? nt;
-  }
-  /**
-   * 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.#h(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.#l(n, "limit");
-    const r = this.#a.get(t) ?? this.#f(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}`, i = this.#c.get(r);
-    if (i !== void 0)
-      return i;
-    const s = _t(this.ranking(t), this.#l(n, "n"));
-    return this.#c.set(r, s), s;
-  }
-  /**
-   * 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.
-   */
-  #l(t, n) {
-    if (!Number.isInteger(t) || t < 0)
-      throw new y({
-        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.#d(t), i = r.kind === "edge" ? this.#t : this.#e;
-    return Dt(V(i, 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.#g(), 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.#s(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.
-   */
-  #m(t) {
-    const n = this.fields.find((r) => r.name === t && r.kind !== "graph");
-    return n !== void 0 && P(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.
-   */
-  #d(t) {
-    const n = this.fields.filter((s) => s.name === t), r = n.find((s) => s.kind !== "graph"), i = this.fields.filter((s) => s.kind !== "graph" && P(s)).map((s) => s.name);
-    if (r === void 0)
-      throw n.length > 0 ? new y({
-        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: i },
-        target: { kind: "run", id: this.runId }
-      }) : new y({
-        code: "E_UNKNOWN_ATTRIBUTE",
-        source: "run",
-        message: `Run "${this.runId}" published no field named "${t}".`,
-        details: { field: t, available: i, candidates: St(t, i) },
-        target: { kind: "run", id: this.runId }
-      });
-    if (!P(r))
-      throw new y({
-        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: i },
-        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.
-   */
-  #p(t) {
-    return this.#d(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.
-   */
-  #h(t) {
-    const n = this.#o.get(t);
-    if (n !== void 0)
-      return n;
-    const r = ke(V(this.#p(t), t));
-    return this.#o.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.
-   */
-  #f(t) {
-    const n = q(Y(this.#p(t), t));
-    return this.#a.set(t, n), n;
-  }
-  /**
-   * Build the bounded form of this result.
-   * @returns The summary.
-   */
-  #g() {
-    const t = Jt(this.shape), n = t === null || this.#m(t) === null ? null : t, r = n === null ? null : this.#h(n).statistics, i = r !== null && r.measured > 0 ? r : null, s = n === null ? [] : this.ranking(n, Gt).map(
-      (c) => Object.freeze({
-        id: c.id,
-        label: this.#i(c.id) ?? String(c.id),
-        value: c.value,
-        rank: c.rank,
-        percentile: c.percentile
-      })
-    ), o = {
-      count: this.#y(),
-      measured: r === null ? this.#b() : r.measured,
-      min: i === null ? null : i.min,
-      max: i === null ? null : i.max,
-      median: i === null ? null : i.median,
-      mean: i === null ? null : i.mean,
-      tiedAtMin: r === null ? 0 : r.tiedAtMin,
-      normalization: this.#w(n),
-      top: Object.freeze(s),
-      caveats: this.#n,
-      durationMs: this.#r
-    }, a = this.graph.sizes ?? this.graph.categories, u = qt(a, Ut, this.shape === "community");
-    return Object.freeze(u === void 0 ? o : { ...o, groups: u });
-  }
-  /**
-   * 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 = B(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 = B(this.shape), { primaryField: n } = t;
-    if (n === null)
-      return 0;
-    const r = t.nodeFields.includes(n) ? ue(this.#e, n) : 0, i = t.edgeFields.includes(n) ? ue(this.#t, n) : 0;
-    return r + i;
-  }
-  /**
-   * 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 ve(n) ? n : t === null ? "none" : Ae(this.fields, t);
-  }
-}
-function Wt(e) {
-  const t = oe(e.nodes), n = oe(e.edges), r = { ...e.graph };
-  Vt(e.shape, t, n, r, e.fields);
-  for (const i of t.records)
-    Object.freeze(i);
-  for (const i of n.records)
-    Object.freeze(i);
-  return new Yt(e, t, n, Object.freeze(r));
-}
-function Kt(e) {
-  const t = e.styles?.config.data.knownFields.nodeLabelPath ?? null;
-  if (t === null)
-    return;
-  const n = e.getDataManager();
-  return (r) => {
-    const i = n.getNode(r)?.data[t];
-    return typeof i == "string" || typeof i == "number" ? String(i) : void 0;
-  };
-}
-function Jn(e) {
-  return { exact: !0, precision: "f64", notes: [], ...e };
-}
-const Zt = 1024, Xt = 16;
-function Qt() {
-  return {
-    signal: new AbortController().signal,
-    report: () => {
-    },
-    yieldNow: () => new Promise((e) => {
-      setTimeout(e, 0);
-    })
-  };
-}
-async function qn(e, t, n, r) {
-  const i = n.length;
-  e.report({ phase: t, completed: 0, total: i });
-  let s = performance.now();
-  for (let o = 0; o < i; o++)
-    o > 0 && o % Zt === 0 && (e.signal.throwIfAborted(), e.report({ phase: t, completed: o, total: i }), performance.now() - s >= Xt && (await e.yieldNow(), s = performance.now())), r(n[o], o);
-  e.signal.throwIfAborted(), e.report({ phase: t, completed: i, total: i });
-}
-function en(e, t, n) {
-  const r = n?.find((s) => s.name === e.name && s.kind === e.kind), i = {
-    name: e.name,
-    plainName: r?.plainName ?? e.name,
-    technicalName: r?.technicalName ?? e.name,
-    kind: e.kind,
-    type: e.type,
-    path: T(t, e.name),
-    ...r?.unit === void 0 ? {} : { unit: r.unit }
-  };
-  return e.normalization === void 0 ? i : { ...i, normalization: e.normalization };
-}
-class Yn extends D {
-  /** 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) : _e(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(Qt(), 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.
-   * @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 i = Date.now(), s = await this.compute(t);
-    if (s === null)
-      return;
-    const o = this.graph.getDataManager(), a = Kt(this.graph), u = Wt({
-      ...a === void 0 ? {} : { labelOf: a },
-      runId: n,
-      shape: s.shape,
-      fields: s.fields.map((c) => en(c, n, r)),
-      measured: { nodes: o.nodes.size, edges: o.edges.size },
-      graph: s.graph,
-      nodes: s.nodes,
-      edges: s.edges,
-      caveats: s.caveats,
-      durationMs: Date.now() - i
-    });
-    return this.#e = u, u;
-  }
-}
-function Wn(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 le = [
-  { 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 Kn(e) {
-  return e ? [...le, { name: "modularity", kind: "graph", type: "number" }] : le;
-}
-const Zn = [
-  { name: "level", kind: "node", type: "integer" },
-  { name: "levelSize", kind: "node", type: "integer" },
-  { name: "levelCount", kind: "graph", type: "integer" },
-  { name: "sizes", kind: "graph", type: "table" }
-], Xn = [
-  { 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 Qn(e, t) {
-  return [
-    { name: "in", kind: e, type: "boolean" },
-    { name: "count", kind: "graph", type: "integer" },
-    { ...t, kind: "graph" }
-  ];
-}
-const tn = `${H}.${wt}`;
-function O(e) {
-  return { ...e, path: `${tn}.${e.name}` };
-}
-function er(e) {
-  return [
-    O({
-      name: "value",
-      plainName: e.plainName,
-      technicalName: e.technicalName,
-      kind: "node",
-      type: e.type ?? "number",
-      ...e.unit === void 0 ? {} : { unit: e.unit }
-    }),
-    O({ name: "rank", plainName: "Rank", technicalName: "rank", kind: "node", type: "integer" }),
-    O({
-      name: "percentile",
-      plainName: "Percentile",
-      technicalName: "percentile",
-      kind: "node",
-      type: "number"
-    }),
-    O({ name: "min", plainName: "Lowest", technicalName: "min", kind: "graph", type: "number" }),
-    O({ name: "max", plainName: "Highest", technicalName: "max", kind: "graph", type: "number" }),
-    O({ name: "median", plainName: "Middle", technicalName: "median", kind: "graph", type: "number" }),
-    O({ name: "mean", plainName: "Average", technicalName: "mean", kind: "graph", type: "number" }),
-    O({
-      name: "measured",
-      plainName: "Measured",
-      technicalName: "measured",
-      kind: "graph",
-      type: "integer"
-    }),
-    O({
-      name: "normalization",
-      plainName: "Normalization",
-      technicalName: "normalization",
-      kind: "graph",
-      type: "string"
-    }),
-    O({
-      name: "tiedAtMin",
-      plainName: "Tied at the lowest value",
-      technicalName: "tiedAtMin",
-      kind: "graph",
-      type: "integer"
-    })
-  ];
-}
-const nn = 12;
-function tr(e, t = {}) {
-  return (rn(e) ? sn(e) : on(e)).map((r) => {
-    const i = { ...r.meta, ...t.meta?.[r.name] }, s = r.node === null ? un(r.name, i, r.failure ?? "the schema could not be converted") : cn(r.name, r.node, i), o = t.overrides?.[r.name];
-    return o === void 0 ? s : { ...s, ...o };
-  });
-}
-function rn(e) {
-  return typeof e != "object" || e === null ? !1 : "_zod" in e || "_def" in e;
-}
-function sn(e) {
-  const t = $e(e);
-  if (t === null)
-    return [];
-  const { properties: n } = t;
-  return n === void 0 ? [] : Object.entries(n).map(([r, i]) => ({ name: r, node: Re(i, t) }));
-}
-function on(e) {
-  const t = Object.entries(e), n = {};
-  for (const [s, o] of t)
-    n[s] = o.schema;
-  const r = an(n), i = r?.properties;
-  return t.map(([s, o]) => {
-    const a = i?.[s];
-    return r === null || a === void 0 ? {
-      name: s,
-      node: null,
-      failure: "the schema could not be converted to JSON Schema",
-      meta: o.meta
-    } : { name: s, node: Re(a, r), meta: o.meta };
-  });
-}
-function $e(e) {
-  try {
-    return me.toJSONSchema(e, { io: "input", unrepresentable: "any" });
-  } catch {
-    return null;
-  }
-}
-function an(e) {
-  try {
-    return $e(me.object(e));
-  } catch {
-    return null;
-  }
-}
-const de = "#/$defs/";
-function Re(e, t) {
-  const n = e.$ref;
-  if (n === void 0 || !n.startsWith(de))
-    return e;
-  const r = n.slice(de.length).replaceAll("~1", "/").replaceAll("~0", "~");
-  return t.$defs?.[r] ?? e;
-}
-function cn(e, t, n) {
-  const r = Ee(t, 0), i = ln(r), s = {
-    name: e,
-    plainName: n.label ?? K(e),
-    technicalName: e,
-    type: i.type
-  }, o = n.description ?? t.description ?? i.node?.description;
-  o !== void 0 && (s.description = o), "default" in t && (s.default = t.default);
-  const a = i.node;
-  if (a !== void 0 && (i.type === "number" || i.type === "integer")) {
-    const c = pe(a.minimum ?? a.exclusiveMinimum), h = pe(a.maximum ?? a.exclusiveMaximum);
-    c !== void 0 && (s.min = c), h !== void 0 && (s.max = h);
-  }
-  const u = n.step ?? a?.multipleOf;
-  return u !== void 0 && (s.step = u), i.values !== void 0 && (s.values = i.values), n.group !== void 0 && (s.group = n.group), n.advanced !== void 0 && (s.advanced = n.advanced), i.unsupportedReason !== void 0 && (s.unsupportedReason = i.unsupportedReason), s;
-}
-function un(e, t, n) {
-  const r = {
-    name: e,
-    plainName: t.label ?? K(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 Ee(e, t) {
-  if (t >= nn)
-    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 i of n) {
-    const s = Ee(i, t + 1);
-    r.arms.push(...s.arms), r.nullable = r.nullable || s.nullable, r.unresolvedRef = r.unresolvedRef || s.unresolvedRef;
-  }
-  return r;
-}
-function ln(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 = pn(e.arms);
-  if (t !== void 0)
-    return { type: "enum", node: e.arms[0], values: t };
-  if (e.arms.length === 1)
-    return dn(e.arms[0]);
-  const n = e.arms.map((r) => Fe(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 dn(e) {
-  switch (Fe(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 pn(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 i = String(r);
-    n.push({ value: i, label: K(i) });
-  }
-  return n;
-}
-function Fe(e) {
-  const { type: t } = e;
-  return typeof t == "string" ? t : Array.isArray(t) && t.length > 0 ? t[0] : "none";
-}
-function pe(e) {
-  if (!(e === Number.MAX_SAFE_INTEGER || e === -Number.MAX_SAFE_INTEGER))
-    return e;
-}
-function K(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 {
-  vt as $,
-  D as A,
-  Mn as B,
-  Le as C,
-  $n as D,
-  Nn as E,
-  On as F,
-  Kt as G,
-  Wt as H,
-  En as I,
-  Rn as J,
-  In as K,
-  Zn as L,
-  Fn as M,
-  Oe as N,
-  b as O,
-  Xn as P,
-  Vn as Q,
-  Gn as R,
-  Dn as S,
-  xn as T,
-  B as U,
-  be as V,
-  St as W,
-  Ln as X,
-  Xt as Y,
-  Pn as Z,
-  jn as _,
-  Yn as a,
-  Un as a0,
-  Bn as a1,
-  Cn as a2,
-  _n as b,
-  Hn as c,
-  kn as d,
-  Kn as e,
-  Jn as f,
-  zn as g,
-  qn as h,
-  Wn as i,
-  Tn as j,
-  vn as k,
-  He as l,
-  O as m,
-  er as n,
-  tr as o,
-  Pe as p,
-  Sn as q,
-  wn as r,
-  Qn as s,
-  H as t,
-  J as u,
-  Ge as v,
-  nt as w,
-  An as x,
-  yt as y,
-  T as z
-};