@graphty/graphty-element 2.3.0 → 2.4.0

package/dist/chunks/optionsFromZod-BuTOFgVM.js

@@ -0,0 +1,2572 @@
+import { q as he, b as Ie } from "./GraphtyLogger-CqOVV13Y.js";
+import { K as Te, f as Me } from "./types-C_c53VgR.js";
+import { G as y } from "./GraphtyError-B93WRH3e.js";
+import { Graph as _e, 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 yn(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 bn() {
+  return _.descriptors();
+}
+function wn(e) {
+  return _.byId(e);
+}
+function vn() {
+  _.clearForTesting();
+}
+const ze = ["forceAtlas2", "fruchtermanReingold", "springElectrical", "release"], Ce = [
+  "pageRank",
+  "sssp",
+  "breadthFirstSearch",
+  "connectedComponents",
+  "weaklyConnectedComponents",
+  "minimumSpanningTree"
+];
+function On(e) {
+  const t = {
+    kind: e.backend
+  };
+  for (const n of ze) {
+    const r = e[n];
+    typeof r == "function" && (t[n] = r.bind(e));
+  }
+  return t;
+}
+function xe(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;
+}
+const je = ["auto", "off", "required"], kn = "auto";
+function Nn(e) {
+  return typeof e == "string" && je.includes(e);
+}
+const Pe = "f64", Sn = "f32", An = "acceleration.minNodes", $n = 0, Rn = "RTX 4070 SUPER, headless Chromium, 2026-09-25", En = 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 Le(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 Fn() {
+  return z.descriptors();
+}
+function In(e) {
+  return z.byId(e);
+}
+function Tn() {
+  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 De(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":
+      Ge(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 Ge(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 Ue(e, t) {
+  const n = {};
+  for (const [r, i] of Object.entries(e)) {
+    const o = t?.[r] ?? i.default;
+    De(r, o, i), n[r] = o;
+  }
+  return n;
+}
+function Mn(e) {
+  return e;
+}
+function He(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 Be(i, t);
+}
+function _n(e) {
+  const t = e.getSnapshot();
+  return t.flags.multigraph ? t.edgeCount - t.simplified({ weights: "sum" }).snapshot.edgeCount : 0;
+}
+function Be(e, t) {
+  const n = new _e({
+    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 = /* @__PURE__ */ new Map();
+function Ve(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 He(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: Ve(s?.edgeRemap ?? null, a?.edgeRemap ?? null),
+      run: async (p) => {
+        const l = await c.run(
+          h,
+          (d) => p(X(xe(d)), u)
+        );
+        return l.accelerated ? { value: l.value, precision: l.precision } : { value: await p(X(null), u), precision: Pe };
+      }
+    };
+  }
+  /**
+   * 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 ? {} : Ue(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, version: a } = n;
+    return s !== void 0 && Le({
+      descriptor: s,
+      namespace: i,
+      type: r,
+      ...o === void 0 ? {} : { cost: o },
+      ...a === void 0 ? {} : { version: a }
+    }), 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 Je(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 Ye(e) {
+  return e[0];
+}
+function We(e, t, n) {
+  const { locale: r, audience: i } = n, s = Je(e, "value", i), o = Ye(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 Ke(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 Ze(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 Xe(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 Qe(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 et(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 tt(e, t) {
+  const n = e.summary(), { shape: r } = e;
+  switch (r) {
+    case "node-metric":
+    case "edge-metric":
+      return We(e, n, t);
+    case "community":
+    case "layered-grouping":
+    case "category-table":
+      return Ke(e, n, t);
+    case "path":
+      return Ze(e, t);
+    case "node-set":
+    case "edge-set":
+      return Xe(e, n, t);
+    case "pair-list":
+      return Qe(e, t);
+    case "temporal":
+      return et(e, t);
+    case "fact":
+      return te(n, t);
+    default:
+      return te(n, t);
+  }
+}
+function zn(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) => nt(r(o, a))),
+    idOf: s ?? null
+  };
+}
+function nt(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 rt = 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"
+}), it = ["&&", "||", "==", "!=", "<=", ">=", "!", "<", ">", ".", "(", ")"];
+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 st(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 ot(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 at(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 ct(e) {
+  const t = [];
+  let n = 0;
+  for (; n < e.length; ) {
+    const r = e.charAt(n);
+    if (/\s/.test(r)) {
+      n++;
+      continue;
+    }
+    const i = rt[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 = it.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: ot(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: st(e.slice(n + 1, o)), at: n }), n = o + 1;
+      continue;
+    }
+    if (r === '"') {
+      const o = x(e, n, '"');
+      t.push({ kind: "identifier", text: at(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 ut = 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 lt(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 dt(e) {
+  const t = N(e);
+  if (t.kind === "literal")
+    return e.index++, { kind: "literal", value: t.value };
+  if (t.kind === "identifier")
+    return lt(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 dt(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" ? ut[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 pt(e) {
+  const t = { where: e, tokens: ct(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 ft(e.operator, e.left, e.right, t);
+  }
+}
+const ht = Object.freeze({
+  "<": (e, t) => e < t,
+  "<=": (e, t) => e <= t,
+  ">": (e, t) => e > t,
+  ">=": (e, t) => e >= t
+});
+function mt(e, t) {
+  return e.kind === "literal" ? e : t.kind === "literal" ? t : null;
+}
+function ft(e, t, n, r) {
+  if (e === "==" || e === "!=") {
+    const a = e === "==", u = t.kind === "literal", c = mt(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 = ht[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 gt(e) {
+  return e.split(".").map((t) => yt(t) ? t : JSON.stringify(t)).join(".");
+}
+function yt(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 Cn(e, t) {
+  const { has: n } = e;
+  return (r) => n(r, t);
+}
+function xn(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 jn(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 Pn(e, t) {
+  const n = pt(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", bt = "$";
+function T(e, t) {
+  return t === void 0 ? `${H}.${e}` : `${H}.${e}.${t}`;
+}
+const be = {
+  // -- 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"]
+  }
+}, Ln = Object.keys(be), q = {
+  "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 q[e];
+}
+function Dn(e) {
+  return q[e].layer === "highlight";
+}
+function Gn(e, t) {
+  const n = q[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 = be[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 && !wt(n, t) && r.push({
+    field: null,
+    kind: "graph",
+    reason: `shape "${e}" requires one graph-level scalar of its own beside "count"`
+  }), r;
+}
+function wt(e, t) {
+  const n = [...e.graphFields, ...e.optionalGraphFields];
+  return t.some((r) => r.kind === "graph" && !n.includes(r.name));
+}
+const vt = 3;
+function Ot(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 kt(e, t, n = vt) {
+  const r = e.toLowerCase(), i = t.map((s) => ({
+    candidate: s,
+    distance: Ot(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 Nt(e) {
+  return typeof e == "string" ? void 0 : e.shape;
+}
+function St(e, t) {
+  return e.fields.some((n) => n.name === t) || t in e.graph;
+}
+class At {
+  #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 = Nt(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 gt(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 || St(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 Un(e) {
+  return new At(e);
+}
+const $t = 20, j = 100, Rt = 100, Et = Object.freeze([]), Ft = Object.freeze(["max", "min-max", "none"]);
+function we(e) {
+  return typeof e == "string" && Ft.includes(e);
+}
+function Hn(e) {
+  return {
+    length: e.length,
+    get: (t) => e[t]
+  };
+}
+const It = Object.freeze({
+  measured: 0,
+  min: Number.NaN,
+  max: Number.NaN,
+  mean: Number.NaN,
+  median: Number.NaN,
+  tiedAtMin: 0,
+  smallestPositive: null
+});
+function ve(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, ...It };
+  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 Oe(e) {
+  const t = ve(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 J(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 Tt(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 Mt(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 _t(e) {
+  return e.measured === 0 || !(e.median > 0) || e.max / e.median <= Rt ? "linear" : Mt(e) ? "log" : "linear";
+}
+function zt(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 Ct(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 xt(e) {
+  if (e === void 0)
+    return $t;
+  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 jt(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 Pt(e, t) {
+  const n = xt(t?.bins), r = t?.integerValued ?? !1, i = ve(e), s = _t(i), o = jt(e, n);
+  if (o !== null) {
+    if (o.size === 0)
+      return Object.freeze({
+        bins: Et,
+        // 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" ? Ct(i.min, i.max, i.smallestPositive, n, r) : null, c = u ?? zt(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 Lt = 10, Dt = 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) => ke(n[r][t])
+  };
+}
+function Y(e, t) {
+  return e.ids.map((n, r) => ({ id: n, value: ke(e.records[r][t]) }));
+}
+function ke(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 Ne(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 Se(e, t) {
+  const n = String(e), r = String(t);
+  return n === r ? 0 : n < r ? -1 : 1;
+}
+function Gt(e) {
+  const t = [...e.entries()].map(([n, r]) => ({ group: n, size: r }));
+  return t.sort((n, r) => r.size - n.size || Se(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 we(n) ? n : "none";
+}
+function ae(e, t, n) {
+  const { statistics: r } = Oe(V(e, "value"));
+  for (const i of J(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 = Ne(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", Gt(s));
+}
+function Ut(e, t) {
+  for (const r of J(Y(e, "score"))) {
+    const i = e.index.get(r.id);
+    i !== void 0 && M(e.records[i], "rank", r.rank);
+  }
+  const n = [...Ne(e, "category").entries()].map(([r, i]) => ({
+    category: String(r),
+    count: i
+  }));
+  n.sort((r, i) => i.count - r.count || Se(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 Ht(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":
+      Ut(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 Bt(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 Vt(e, t) {
+  if (!Array.isArray(e))
+    return;
+  const n = [];
+  for (const r of e) {
+    if (typeof r != "object" || r === null)
+      continue;
+    const i = r, s = i.group ?? i.category, o = i.size ?? i.count;
+    if (W(s) && typeof o == "number" && n.push(Object.freeze({ group: s, size: o })), n.length === t)
+      break;
+  }
+  return Object.freeze(n);
+}
+class qt {
+  #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 ?? tt;
+  }
+  /**
+   * 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 = Tt(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 Pt(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: kt(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 = Oe(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 = J(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 = Bt(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, Lt).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 = Vt(a, Dt);
+    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 we(n) ? n : t === null ? "none" : Ae(this.fields, t);
+  }
+}
+function Jt(e) {
+  const t = oe(e.nodes), n = oe(e.edges), r = { ...e.graph };
+  Ht(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 qt(e, t, n, Object.freeze(r));
+}
+function Yt(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 Bn(e) {
+  return { exact: !0, precision: "f64", notes: [], ...e };
+}
+const Wt = 1024, Kt = 16;
+function Zt() {
+  return {
+    signal: new AbortController().signal,
+    report: () => {
+    },
+    yieldNow: () => new Promise((e) => {
+      setTimeout(e, 0);
+    })
+  };
+}
+async function Vn(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 % Wt === 0 && (e.signal.throwIfAborted(), e.report({ phase: t, completed: o, total: i }), performance.now() - s >= Kt && (await e.yieldNow(), s = performance.now())), r(n[o], o);
+  e.signal.throwIfAborted(), e.report({ phase: t, completed: i, total: i });
+}
+function Xt(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 qn 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) : Ie(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(Zt(), 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 = Yt(this.graph), u = Jt({
+      ...a === void 0 ? {} : { labelOf: a },
+      runId: n,
+      shape: s.shape,
+      fields: s.fields.map((c) => Xt(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 Jn(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 Yn(e) {
+  return e ? [...le, { name: "modularity", kind: "graph", type: "number" }] : le;
+}
+const Wn = [
+  { name: "level", kind: "node", type: "integer" },
+  { name: "levelSize", kind: "node", type: "integer" },
+  { name: "levelCount", kind: "graph", type: "integer" },
+  { name: "sizes", kind: "graph", type: "table" }
+], Kn = [
+  { 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 Zn(e, t) {
+  return [
+    { name: "in", kind: e, type: "boolean" },
+    { name: "count", kind: "graph", type: "integer" },
+    { ...t, kind: "graph" }
+  ];
+}
+const Qt = `${H}.${bt}`;
+function O(e) {
+  return { ...e, path: `${Qt}.${e.name}` };
+}
+function Xn(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 en = 12;
+function Qn(e, t = {}) {
+  return (tn(e) ? nn(e) : rn(e)).map((r) => {
+    const i = { ...r.meta, ...t.meta?.[r.name] }, s = r.node === null ? an(r.name, i, r.failure ?? "the schema could not be converted") : on(r.name, r.node, i), o = t.overrides?.[r.name];
+    return o === void 0 ? s : { ...s, ...o };
+  });
+}
+function tn(e) {
+  return typeof e != "object" || e === null ? !1 : "_zod" in e || "_def" in e;
+}
+function nn(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 rn(e) {
+  const t = Object.entries(e), n = {};
+  for (const [s, o] of t)
+    n[s] = o.schema;
+  const r = sn(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 sn(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 on(e, t, n) {
+  const r = Ee(t, 0), i = cn(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 an(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 >= en)
+    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 cn(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 = ln(e.arms);
+  if (t !== void 0)
+    return { type: "enum", node: e.arms[0], values: t };
+  if (e.arms.length === 1)
+    return un(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 un(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 ln(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 {
+  Un as $,
+  D as A,
+  In as B,
+  Pe as C,
+  Sn as D,
+  On as E,
+  wn as F,
+  Yt as G,
+  Jt as H,
+  $n as I,
+  An as J,
+  En as K,
+  Wn as L,
+  Rn as M,
+  ve as N,
+  b as O,
+  Kn as P,
+  Hn as Q,
+  Ln as R,
+  Pn as S,
+  zn as T,
+  B as U,
+  kt as V,
+  jn as W,
+  xn as X,
+  Kt as Y,
+  Cn as Z,
+  Dn as _,
+  qn as a,
+  _n as a0,
+  Tn as b,
+  Gn as c,
+  vn as d,
+  Yn as e,
+  Bn as f,
+  Mn as g,
+  Vn as h,
+  Jn as i,
+  Fn as j,
+  bn as k,
+  Ue as l,
+  O as m,
+  Xn as n,
+  Qn as o,
+  je as p,
+  kn as q,
+  yn as r,
+  Zn as s,
+  H as t,
+  q as u,
+  De as v,
+  tt as w,
+  Nn as x,
+  gt as y,
+  T as z
+};