@graphty/graphty-element 2.6.1 → 3.0.0

package/dist/chunks/fields-5uVC1Pll.js

@@ -0,0 +1,4999 @@
+import { remapArray as st, INVALID_INDEX as g, maskTest as C, GraphBuilder as Sn, makeMask as re, maskSet as En } from "@graphty/graph-format";
+import { fromPositionColumn as In, toPositionColumn as $n } from "@graphty/layout";
+import { z as se } from "zod/v4";
+import { c as Ge, G as m, S as xt } from "./pluginRegistry-Ddfl6Mv2.js";
+import { b as Rn, K as Mn, f as Cn } from "./types-DFchv4Ny.js";
+import { b as _n } from "./GraphtyLogger-BtcBJQPL.js";
+import { Graph as Fn, accelerated as it } from "@graphty/algorithms";
+const ge = Ge({
+  kind: "layout",
+  idOf: (t) => t.descriptor.id,
+  descriptorOf: (t) => t.descriptor,
+  implementationOf: (t) => t.descriptor,
+  builtInIds: () => Rn
+});
+function Tn(t, e) {
+  ge.register(t, e);
+}
+function ai() {
+  return ge.descriptors();
+}
+function ci(t) {
+  return ge.byId(t);
+}
+function ui() {
+  ge.clearForTesting();
+}
+const b = 3, Pn = 1024;
+function V(t, e) {
+  if (!Number.isInteger(t) || t < 0)
+    throw new RangeError(`ElementPositions: ${e} must be a non-negative integer, found ${String(t)}`);
+  return t;
+}
+function P(t) {
+  return Number.isFinite(Math.fround(t));
+}
+class zt {
+  /**
+   * Allocate the backing array, every row unplaced and unpinned.
+   * @param capacity - rows to reserve before the first growth; a non-negative integer
+   */
+  constructor(e = Pn) {
+    this.components = b, this.rows = 0, this.moves = 0, V(e, "capacity");
+    const n = Math.max(1, e);
+    this.array = new Float32Array(b * n), this.array.fill(Number.NaN), this.pins = new Uint8Array(n);
+  }
+  /**
+   * Rows the backing array can hold without reallocating.
+   * @returns the current capacity in rows
+   */
+  get capacity() {
+    return this.array.length / b;
+  }
+  /**
+   * Moves whenever coordinates are written on purpose: by {@link ElementPositions.write}, which
+   * every layout, drag and placement goes through, and by {@link ElementPositions.moved}, which a
+   * writer that fills the array {@link ElementPositions.view} lends (a GPU readback, a restore)
+   * calls once per batch. Seeding a new row and renumbering rows do not move it: those follow
+   * the graph, not the arrangement. The undo history compares it with the generation of its
+   * last capture to tell whether the lane has moved since (design/undo/undo-design.md 6.4).
+   * @returns the generation
+   */
+  get generation() {
+    return this.moves;
+  }
+  /** Say that coordinates were written straight into the lent array. */
+  moved() {
+    this.moves++;
+  }
+  /**
+   * Rows currently in use. Equals the last snapshot's nodeCount.
+   * @returns the live row count
+   */
+  get count() {
+    return this.rows;
+  }
+  /**
+   * How many live rows carry real coordinates, by the same test {@link ElementPositions.isPlaced}
+   * applies one row at a time.
+   *
+   * The question behind it is "did the file that loaded this graph place every node?", which is
+   * what decides whether the Keep Positions arrangement can be used at all: a fixed layout over a
+   * graph where half the rows are NaN draws half a picture. Compare it against
+   * {@link ElementPositions.count} to answer that -- equal means every node has somewhere to go.
+   *
+   * COUNTED ON EVERY READ, and it has to be. The array is lent to the snapshot as a mutable
+   * column, so a layout, a drag and a GPU readback all write coordinates without passing through
+   * this class; a counter kept up to date by `write()` would miss every one of those and would be
+   * most wrong exactly while a layout was running, which is when somebody is asking. The scan is
+   * one f32 read per node and touches only the x lane.
+   *
+   * This is deliberately NOT on `GraphStatistics`. Those are memoised against the snapshot they
+   * were computed from, and how many nodes carry a coordinate changes while a layout runs WITHIN
+   * one snapshot, so a cached answer would be stale in the one moment it mattered.
+   * @returns how many rows in `[0, count)` carry a storable x
+   */
+  get placedCount() {
+    let e = 0;
+    for (let n = 0; n < b * this.rows; n += b)
+      this.hasStorableX(n) && e++;
+    return e;
+  }
+  /**
+   * The exact view to hand to `snapshot.nodes.set("position", ...)`.
+   *
+   * Bounded by the LIVE ROW COUNT, like every other row accessor here. `subarray` CLAMPS rather
+   * than throwing, so without a check a caller that forgot to `grow()` first would get a short
+   * array: E_COLUMN_LENGTH from inside graph-format if it is attached, and a layout that silently
+   * places only the first `count` nodes if it is not. Bounding by the CAPACITY instead would hand
+   * out a writable window over the spare rows -- rows this class reports unplaced, whose NaN fill
+   * every later `grow()` and `remap()` depends on, and whose contents the next growth erases.
+   * @param nodeCount - the snapshot's node count
+   * @returns a subarray of length `3 * nodeCount` over the same buffer
+   * @throws RangeError when `nodeCount` is not a non-negative integer, or exceeds the live count
+   */
+  view(e) {
+    if (V(e, "nodeCount"), e > this.rows)
+      throw new RangeError(
+        `ElementPositions: view(${e}) needs ${e} live rows but only ${this.rows} exist; call grow(${e}) first`
+      );
+    return this.array.subarray(0, b * e);
+  }
+  /**
+   * Prefix-stable growth: existing rows keep their coordinates, EVERY row at or above the new
+   * count is unplaced -- including the spare capacity, which a later grow() will hand out.
+   *
+   * Past the capacity this REPLACES the array object; see the staleness contract on the class.
+   * @param nodeCount - the new row count; may be smaller than the current one (append-only
+   *     builders never shrink, but a caller that does gets a truncation, not a throw). `grow(0)`
+   *     is how a dataset is discarded while the reserve is kept
+   * @throws RangeError when `nodeCount` is not a non-negative integer
+   */
+  grow(e) {
+    if (V(e, "nodeCount"), e > this.capacity) {
+      const n = Math.max(this.capacity * 2, e), r = new Float32Array(b * n);
+      r.set(this.array), r.fill(Number.NaN, b * this.rows), this.array = r;
+      const s = new Uint8Array(n);
+      s.set(this.pins), s.fill(0, this.rows), this.pins = s;
+    } else e > this.rows ? (this.array.fill(Number.NaN, b * this.rows, b * e), this.pins.fill(0, this.rows, e)) : e < this.rows && (this.array.fill(Number.NaN, b * e, b * this.rows), this.pins.fill(0, e, this.rows));
+    this.rows = e;
+  }
+  /**
+   * Apply a freeze report's `nodeRemap` (previous index space -> new index or INVALID_INDEX).
+   *
+   * `remapArray` ALLOCATES, so this replaces the array object and collapses the capacity to
+   * exactly `nodeCount` (PLAN DECISION 3: a removal is rare and never per frame, so paying one
+   * reallocation on the next growth is cheaper than copying the remapped rows a second time into
+   * a re-reserved array). Every holder of the old object is stale afterwards, which is why
+   * GraphStore re-attaches the column on every freeze and emits `snapshot-replaced`.
+   * @param nodeRemap - the report's nodeRemap
+   * @param nodeCount - the new snapshot's node count
+   * @throws RangeError when `nodeCount` is not a non-negative integer
+   */
+  remap(e, n) {
+    V(n, "nodeCount"), this.array = st(this.array, e, n, Number.NaN, b), this.pins = st(this.pins, e, n, 0, 1), this.rows = n;
+  }
+  /**
+   * Whether the reader has fixed this row's node in place.
+   *
+   * A row outside the live count is UNPINNED, never pinned, for the same reason
+   * {@link ElementPositions.isPlaced} answers false there: a node with no row is a node the
+   * graph builder has not taken, and answering "pinned" for one would freeze a node that does
+   * not exist yet and that nothing could release.
+   * @param index - node index
+   * @returns true when the row is inside the live count AND carries a pin
+   */
+  isPinned(e) {
+    return !Number.isInteger(e) || e < 0 || e >= this.rows ? !1 : this.pins[e] === 1;
+  }
+  /**
+   * Record or release a pin, GROWING the lane to reach the row.
+   *
+   * It grows rather than throwing for the same reason `LayoutEngine.writeNodePosition` does: a
+   * node's index is handed out the moment the graph builder takes its record, but its row only
+   * appears when the graph is next frozen, and a reader who drags a node in between would
+   * otherwise have the pin thrown away in silence.
+   *
+   * It REFUSES rather than throwing for an index that is not a row number at all -- the
+   * `INVALID_INDEX` a record the builder would not take carries for its whole life, or a
+   * negative or fractional number. Pinning happens from a pointer gesture, and a throw on that
+   * path takes the frame with it.
+   * @param index - node index
+   * @param pinned - true to pin, false to release
+   * @returns true when the lane was written, false when the index names no row
+   */
+  setPinned(e, n) {
+    return e === g || !Number.isInteger(e) || e < 0 ? !1 : (e >= this.rows && this.grow(e + 1), this.pins[e] = n ? 1 : 0, !0);
+  }
+  /**
+   * How many live rows are pinned.
+   * @returns the count of pinned rows in `[0, count)`
+   */
+  get pinnedCount() {
+    let e = 0;
+    for (let n = 0; n < this.rows; n++)
+      this.pins[n] === 1 && e++;
+    return e;
+  }
+  /**
+   * The exact view to hand to `snapshot.nodes.set("graphty.pinned", ...)`.
+   *
+   * Bounded by the live row count, like {@link ElementPositions.view} and for the same reasons.
+   * @param nodeCount - the snapshot's node count
+   * @returns a subarray of length `nodeCount` over the same buffer
+   * @throws RangeError when `nodeCount` is not a non-negative integer, or exceeds the live count
+   */
+  pinnedView(e) {
+    if (V(e, "nodeCount"), e > this.rows)
+      throw new RangeError(
+        `ElementPositions: pinnedView(${e}) needs ${e} live rows but only ${this.rows} exist; call grow(${e}) first`
+      );
+    return this.pins.subarray(0, e);
+  }
+  /**
+   * Report whether a row carries real coordinates.
+   *
+   * A row outside the live count is UNPLACED, never placed: this predicate is used to decide
+   * whether an importer seed may be written, and answering "placed" for a row that does not
+   * exist is how a coordinate gets thrown away without an error. So is a row whose x is an
+   * infinity, which only a writer that bypassed `write()` -- that is, one writing through the
+   * column this array is lent to -- can produce; see the class comment.
+   * @param index - node index
+   * @returns true when the row is inside the live count AND carries a storable x
+   */
+  isPlaced(e) {
+    return !Number.isInteger(e) || e < 0 || e >= this.rows ? !1 : this.hasStorableX(b * e);
+  }
+  /**
+   * Read one row into a caller-supplied object (14.4 rule 7: never return a shared vector).
+   * @param index - node index
+   * @param out - the object to fill
+   * @param out.x - receives the scene-unit x
+   * @param out.y - receives the scene-unit y
+   * @param out.z - receives the scene-unit z
+   * @throws RangeError when `index` is not an integer in `[0, count)`
+   */
+  read(e, n) {
+    const r = this.rowBase(e);
+    n.x = this.array[r] ?? Number.NaN, n.y = this.array[r + 1] ?? Number.NaN, n.z = this.array[r + 2] ?? Number.NaN;
+  }
+  /**
+   * Write one row.
+   *
+   * This is the ONE choke point every layout, every drag and (from E1) every GPU readback goes
+   * through, so it is where an unstorable coordinate is stopped. NaN is this class's unplaced
+   * marker: letting one in through here would unplace a placed node from the inside, and an
+   * infinity would be stored and then reported placed. The test is `isStorableCoordinate`, NOT
+   * `Number.isFinite`, because the array is f32: a finite double of 1e39 passes `isFinite` and
+   * lands as Infinity. A caller holding such a coordinate has a bug upstream and must drop the
+   * update, not hand it on.
+   * @param index - node index
+   * @param x - scene-unit x
+   * @param y - scene-unit y
+   * @param z - scene-unit z
+   * @throws RangeError when `index` is not an integer in `[0, count)`. A node added since the
+   *     last freeze has no row yet: freeze first (which grows this array), then write
+   * @throws RangeError when any component is NaN, an infinity, or a double that overflows f32
+   */
+  write(e, n, r, s) {
+    const i = this.rowBase(e);
+    if (!P(n) || !P(r) || !P(s))
+      throw new RangeError(
+        `ElementPositions: row ${String(e)} was written the unstorable coordinate (${String(n)}, ${String(r)}, ${String(s)}); NaN is this class's UNPLACED marker, and an infinity -- including one an f32 overflow produces -- poisons the scene bounds`
+      );
+    this.array[i] = n, this.array[i + 1] = r, this.array[i + 2] = s, this.moves++;
+  }
+  /**
+   * Write a row ONLY when it is unplaced. This is how importer-seeded coordinates reach a new
+   * node without overwriting anything a layout or a drag already produced.
+   *
+   * `false` means exactly one thing -- the row was ALREADY PLACED, by the same test `isPlaced()`
+   * applies. A row that does not exist yet throws instead of returning `false`, so a caller that
+   * seeds before growing finds out rather than losing the coordinate.
+   * @param index - node index
+   * @param x - scene-unit x
+   * @param y - scene-unit y
+   * @param z - scene-unit z
+   * @returns true when the row was written, false when it was already placed
+   * @throws RangeError when `index` is not an integer in `[0, count)`
+   * @throws RangeError when any component is NaN, an infinity, or a double that overflows f32,
+   *     through `write()`
+   */
+  fillUnplaced(e, n, r, s) {
+    const i = this.rowBase(e);
+    return this.hasStorableX(i) ? !1 : (this.write(e, n, r, s), this.moves--, !0);
+  }
+  /**
+   * Whether the row at this offset carries a storable x, which is the one test "placed" means.
+   * @param base - the array offset of the row's x component
+   * @returns true when the stored x is neither NaN nor an infinity
+   */
+  hasStorableX(e) {
+    return P(this.array[e] ?? Number.NaN);
+  }
+  /**
+   * The array offset of a live row, rejecting anything else.
+   * @param index - node index
+   * @returns the offset of the row's x component
+   */
+  rowBase(e) {
+    if (!Number.isInteger(e) || e < 0 || e >= this.rows)
+      throw new RangeError(
+        e === g ? "ElementPositions: INVALID_INDEX is the graph-format 'no node' sentinel, not a row" : `ElementPositions: row ${String(e)} is outside the live range [0, ${this.rows})`
+      );
+    return b * e;
+  }
+}
+const xn = /* @__PURE__ */ Symbol("graphty.writableLane");
+function Lt(t) {
+  if (t === void 0)
+    return;
+  const e = t[xn];
+  if (e !== void 0)
+    return e;
+  const n = t.positions;
+  return n instanceof zt ? n : void 0;
+}
+function zn(t) {
+  return {
+    get capacity() {
+      return t().capacity;
+    },
+    get count() {
+      return t().count;
+    },
+    get placedCount() {
+      return t().placedCount;
+    },
+    get pinnedCount() {
+      return t().pinnedCount;
+    },
+    get generation() {
+      return t().generation;
+    },
+    isPlaced: (e) => t().isPlaced(e),
+    isPinned: (e) => t().isPinned(e),
+    read: (e, n) => {
+      t().read(e, n);
+    }
+  };
+}
+const M = new xt("layout"), Ln = Object.freeze([
+  "arf",
+  "bfs",
+  "bipartite",
+  "circular",
+  "d3",
+  "fixed",
+  "forceatlas2",
+  "grid",
+  "kamada-kawai",
+  "multipartite",
+  "ngraph",
+  "planar",
+  "radial",
+  "random",
+  "shell",
+  "spectral",
+  "spiral",
+  "spring",
+  "spring-electrical"
+]), Dn = 10;
+function ot(t) {
+  return new m({
+    code: "E_DUPLICATE_PLUGIN",
+    message: `"${t}" is a layout engine the element ships, and a built-in name may not be taken: a saved document that named it yesterday has to mean the same thing today`,
+    source: "registry",
+    details: { kind: "layout", name: t, builtIn: !0 }
+  });
+}
+const S = {};
+function jn(t, e) {
+  const n = [], r = /* @__PURE__ */ new Set();
+  for (const s of t)
+    r.has(s) && n.push(`edge ${s.id} is held twice`), r.add(s), e.get(s.id) !== s && n.push(`edge ${s.id} is held but not drawn`);
+  for (const s of e.values())
+    r.has(s) || n.push(`edge ${s.id} is drawn but not held`);
+  return n;
+}
+const pe = class pe {
+  constructor() {
+    this.positionArrayAttached = !1, this.hold = null, this.holdRows = 0, this.readonlyPositionArray = zn(() => this.writablePositions);
+  }
+  /**
+   * Add multiple nodes to the layout engine
+   * @param nodes - Array of nodes to add
+   */
+  addNodes(e) {
+    for (const n of e)
+      this.addNode(n);
+  }
+  /**
+   * Add multiple edges to the layout engine
+   * @param edges - Array of edges to add
+   */
+  addEdges(e) {
+    for (const n of e)
+      this.addEdge(n);
+  }
+  /**
+   * Take a node out of the layout, before the element disposes the mesh that drew it.
+   *
+   * Declared here, with a default that does nothing, because it used to be duck-typed by the
+   * element's data manager and implemented by none of the nineteen engines that ship here: an
+   * author learned it existed by reading the element's source, and got no worked example. An
+   * engine that keeps its own node list must override this, or it holds every removed node --
+   * and everything that node references -- for as long as the engine lives.
+   * @param _n - the node leaving the graph
+   */
+  removeNode(e) {
+  }
+  /**
+   * The edge half of {@link LayoutEngine.removeNode}, with the same default and the same reason.
+   * @param _e - the edge leaving the graph
+   */
+  removeEdge(e) {
+  }
+  /**
+   * Settle nodes that reached the graph after this layout was already running.
+   *
+   * THE DEFAULT IS THE ELEMENT'S OWN FALLBACK -- up to ten steps, stopping early if the engine
+   * settles -- so a simulation behaves exactly as it did before the hook was declared, and an
+   * engine that can place a newcomer without re-running the whole simulation overrides it. It
+   * lives on the base class rather than in the manager because the manager cannot tell "did not
+   * implement it" from "implemented it as a deliberate no-op", and the difference decides
+   * whether ten steps run.
+   * @param _nodes - the nodes that have just arrived
+   */
+  updatePositions(e) {
+    for (let n = 0; n < Dn; n++) {
+      if (this.isSettled)
+        return;
+      this.step();
+    }
+  }
+  /**
+   * Release whatever this engine holds. The element calls it when the reader switches layouts
+   * and when the graph is torn down, and never uses the engine again afterwards.
+   *
+   * Declared with a do-nothing default for the same reason as `removeNode`:
+   * it was duck-typed, undeclared and unimplemented by every engine here.
+   */
+  dispose() {
+  }
+  /**
+   * Strict state: what is wrong with this engine's hold on the drawn edges, checked after every
+   * derivation pass. An engine that keeps a copy of the edges must hold every drawn edge once
+   * and nothing else, or a redraw asks it for a position it cannot give. Reads nothing lazily:
+   * the check must not change what it checks.
+   * @param drawn - The edges the element draws.
+   * @returns One sentence per problem; empty when there is none.
+   */
+  edgeProblems(e) {
+    return jn(this.edges, e);
+  }
+  /**
+   * The coordinates this engine publishes, read-only.
+   *
+   * Read-only because the array is the element's: a write here would move or pin a node with no
+   * undo step. The engine writes through `writeNodePosition`; a consumer
+   * places and pins nodes through `session.positions`.
+   * @returns the coordinates in use, read-only
+   */
+  get nodePositions() {
+    return this.readonlyPositionArray;
+  }
+  /**
+   * The array this engine publishes node coordinates into, writable.
+   *
+   * Allocated on demand, so reading it is enough to make an engine that has never been handed an
+   * element's array produce one of its own. The element reaches it through
+   * {@link layoutEngineInternals}.
+   * @returns the position array in use
+   */
+  get writablePositions() {
+    return this.positionArray ??= new zt(0), this.positionArray;
+  }
+  /**
+   * Hand this engine the array it must publish into, and stop it adopting any other.
+   *
+   * This is how a host says "these coordinates are mine": the engine writes into the array the
+   * host already lends to its snapshots, so a layout, a drag and a GPU readback all land in the
+   * one place and a re-freeze loses none of them.
+   * @param positions - the element-owned array
+   */
+  attachPositions(e) {
+    this.positionArray = e, this.positionArrayAttached = !0;
+  }
+  /**
+   * Hold the nodes a scoped layout may not move, or release them all with null.
+   *
+   * The element calls this on an engine whose class declares `static scoped = true`, after
+   * `init()` and after every renumbering of the graph. A set bit is a held row. A row at or past
+   * `rows` belongs to a node that arrived after the scope was captured, and is held too: the
+   * members of a scoped layout are the ones it started with. An engine that overrides this calls
+   * `super.setHoldMask` first and then fixes held nodes in its own state (see
+   * {@link LayoutEngineStatics.scoped}).
+   * @param mask - One bit per row, set for a row to hold; null holds nothing.
+   * @param rows - How many rows the mask covers.
+   */
+  setHoldMask(e, n) {
+    this.hold = e, this.holdRows = e === null ? 0 : n;
+  }
+  /**
+   * The hold mask the element last handed this engine, or null when nothing is held.
+   * @returns The mask, which the caller must not change.
+   */
+  get holdMask() {
+    return this.hold;
+  }
+  /**
+   * Whether the element is holding this row still for a scoped layout.
+   * @param index - The node's row, or `INVALID_INDEX`.
+   * @returns True while a hold is set and the row is held or newer than the hold.
+   */
+  isHeld(e) {
+    const { hold: n } = this;
+    return n === null ? !1 : e >= this.holdRows || !Number.isInteger(e) || e < 0 || C(n, e);
+  }
+  /**
+   * Copy every node's current coordinates out of the engine and into the position array.
+   *
+   * Engines call this at the end of a step, so that by the time anything draws, the array is the
+   * answer rather than a copy of it. The default walks the engine's own nodes through
+   * {@link LayoutEngine.getNodePosition}, which is correct for any engine but allocates one
+   * object per node; an engine that can read its own state without allocating overrides it, and
+   * an engine that already writes straight into the array overrides it to do nothing.
+   */
+  publishPositions() {
+    for (const e of this.nodes) {
+      const n = this.getNodePosition(e);
+      this.writeNodePosition(e, n.x, n.y, n.z ?? 0);
+    }
+  }
+  /**
+   * Take the coordinates in the position array as this engine's own, and stay at rest.
+   *
+   * Undo and redo write where the nodes were into the array and then call this, so the next
+   * drag, add or `setRunning(true)` starts from the restored arrangement instead of the one the
+   * engine was holding. The default hands every placed node back through
+   * `setNodePosition`, which is right for any engine that keeps coordinates of
+   * its own; an engine that can adopt the array in one pass overrides it.
+   */
+  loadArrangement() {
+    const e = { x: 0, y: 0, z: 0 };
+    for (const n of this.nodes)
+      this.readNodePosition(n, e) && this.setNodePosition(n, e);
+  }
+  /**
+   * Read a node's published coordinates into an object the CALLER owns.
+   *
+   * The point of the out parameter is that a renderer can pass the vector it is about to draw
+   * with and allocate nothing per node per frame. A row that no engine has placed answers false
+   * and leaves `out` untouched, so the caller keeps whatever it had rather than being handed a
+   * NaN or an origin it cannot tell from a real coordinate.
+   * @param n - the node to read
+   * @param out - the object to fill; a Babylon `Vector3` is one, which is the point
+   * @param out.x - receives the scene-unit x
+   * @param out.y - receives the scene-unit y
+   * @param out.z - receives the scene-unit z
+   * @returns true when the node has a placed row
+   */
+  readNodePosition(e, n) {
+    const r = this.positionsFor(e);
+    return r.isPlaced(e.index) ? (r.read(e.index, n), !0) : !1;
+  }
+  /**
+   * Publish one node's coordinates, growing the array to reach its row.
+   *
+   * Three things are silently skipped rather than thrown, because this runs inside a layout step
+   * and a throw there kills the frame: a node with no row in the graph (`INVALID_INDEX`, which a
+   * record whose id the graph builder would not take carries for its whole life), a node whose
+   * index is not a row number at all, and a coordinate that cannot be stored. That last one is
+   * the important one -- a force layout that divided by a zero distance produces NaN, and an
+   * overflow of the f32 the array stores produces an infinity. Either one, written, would make
+   * the row read back as a place: the mesh vanishes and the scene bounds and camera framing go
+   * with it. Left alone, the row stays unplaced and the node keeps the coordinates it had.
+   *
+   * The array is GROWN to reach the row rather than the write being refused. A node's index is
+   * handed out the moment its record is taken, but its row only appears when the graph is next
+   * frozen, and a layout that ran in between would otherwise be thrown away in silence. Growth is
+   * prefix-stable and fills what it adds with NaN, so it cannot disturb a row anything else
+   * placed; the one thing it does change is that a node this engine placed before the first
+   * freeze counts as placed, which is what makes a file's own coordinates yield to it.
+   *
+   * A PINNED ROW REFUSES A LAYOUT STEP. This is the whole of "a pin is meaningful under every
+   * arrangement": fourteen of the element's nineteen engines implement `pin()` as a no-op and
+   * `setNodePosition` as a no-op too, so before this guard a reader who dragged a node under a
+   * static layout watched it snap back the next time the layout recomputed. One refusal here
+   * covers every engine, including one written by a third party that has never heard of pinning,
+   * because every engine reaches the shared array through this method.
+   *
+   * A DRAG IS NOT A LAYOUT STEP. `intent: "placement"` writes straight through, so a reader can
+   * move a pinned node and have it stay where they put it; without that distinction the guard
+   * would make a pinned node undraggable, which is the opposite of what a pin is for. The
+   * default is `"layout"` so that an engine written before the parameter existed -- a plugin's
+   * step loop -- is guarded without knowing it, and only the placement paths have to opt out.
+   * @param n - the node being placed
+   * @param x - scene-unit x
+   * @param y - scene-unit y
+   * @param z - scene-unit z
+   * @param intent - `"layout"` for a simulation step, `"placement"` for a drag or a replay
+   * @returns true when the row was written
+   */
+  writeNodePosition(e, n, r, s, i = "layout") {
+    const { index: o } = e;
+    if (o === g || !Number.isInteger(o) || o < 0 || !P(n) || !P(r) || !P(s))
+      return !1;
+    const a = this.positionsFor(e);
+    return i === "layout" && (a.isPinned(o) || this.isHeld(o) && a.isPlaced(o)) ? !1 : (o >= a.count && a.grow(o + 1), a.write(o, n, r, s), !0);
+  }
+  /**
+   * The array to use for this node: the one its own graph owns, unless a host attached one.
+   *
+   * Resolved on every call rather than cached, because the element REPLACES its array when a
+   * dataset is discarded -- the store and everything keyed into it is thrown away and rebuilt --
+   * and an engine outlives that. A cached reference would keep publishing into the array of a
+   * graph that no longer exists, which is invisible: every write succeeds and nothing draws.
+   * @param n - the node being published or read
+   * @returns the array to write to and read from
+   */
+  positionsFor(e) {
+    if (!this.positionArrayAttached) {
+      const n = Lt(e.parentGraph?.getDataManager?.());
+      n !== void 0 && (this.positionArray = n);
+    }
+    return this.writablePositions;
+  }
+  /**
+   * Get the type identifier for this layout engine
+   * @returns The layout engine type string
+   */
+  get type() {
+    return this.constructor.type;
+  }
+  /**
+   * File a layout engine class under the name it declares, and publish what it says about
+   * itself to the catalogue.
+   *
+   * WHAT CHANGED AND WHY. This used to read `cls.type` through a cast and put the class in a
+   * map, which meant a class with no `static type` registered under the string "undefined", a
+   * second class under a taken name silently replaced the first, and a registered engine
+   * reached no catalogue at all -- so a third party's layout could run but could never be
+   * offered by a picker, described in a reader's language, or found by `layoutIdForEngine`.
+   *
+   * A third party's class must declare a `static descriptor` whose `id` equals its
+   * `static type`. The element's own nineteen are the one exemption, because their arrangements
+   * are authored centrally in the layout catalogue where several engines may sit behind one
+   * public name.
+   * @param cls - The layout engine class.
+   * @param options - How to register it; `strict` refuses a different layout under a taken id.
+   * @returns The same class, so a declaration can register itself in one expression.
+   * @throws A `GraphtyError` with `E_BAD_COMMAND` when the class declares no `static type`, no
+   * `static descriptor`, or a descriptor whose `id` disagrees with its `static type`; or with
+   * `E_DUPLICATE_PLUGIN` when the name or the descriptor id is one the element itself ships.
+   */
+  static register(e, n) {
+    const r = e, { type: s, descriptor: i } = r;
+    if (typeof s != "string" || s === "")
+      throw new m({
+        code: "E_BAD_COMMAND",
+        message: "a layout engine is filed under its `static type`, and this class declares none",
+        source: "registry",
+        details: { kind: "layout", field: "type" }
+      });
+    if (M.get(s) === e)
+      return e;
+    const o = Ln.includes(s);
+    if (i === void 0) {
+      if (!o)
+        throw new m({
+          code: "E_BAD_COMMAND",
+          message: `the layout "${s}" declares no \`static descriptor\`, so nothing could offer it: a picker reads the catalogue, and an engine the catalogue does not carry is reachable only by a consumer who already knows its name`,
+          source: "registry",
+          details: { kind: "layout", name: s, field: "descriptor" }
+        });
+      if (M.hasOwn(s))
+        throw ot(s);
+      return M.set(s, e), e;
+    }
+    if (o)
+      throw ot(s);
+    if (i.id !== s)
+      throw new m({
+        code: "E_BAD_COMMAND",
+        message: `the layout "${s}" describes itself as "${i.id}". A layout has ONE key: the name \`setLayout\` takes and the name the catalogue publishes are the same string, so nothing has to be named twice and a saved document means one thing`,
+        source: "registry",
+        details: { kind: "layout", name: s, field: "descriptor.id", id: i.id }
+      });
+    return Tn(
+      {
+        descriptor: {
+          ...i,
+          honoursWeights: r.honoursWeights ?? !1,
+          scoped: r.scoped ?? !1
+        },
+        type: s
+      },
+      n
+    ), M.set(s, e), e;
+  }
+  /**
+   * Get a layout engine instance by type
+   * @param type - The layout engine type identifier
+   * @param opts - Configuration options for the layout engine
+   * @returns A new layout engine instance or null if type not found
+   */
+  static get(e, n = {}) {
+    const r = M.get(e);
+    return r ? new r(n) : null;
+  }
+  /**
+   * Get dimension-specific options for this layout
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object for the dimension or null if unsupported
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : {};
+  }
+  /**
+   * Get dimension-specific options for a layout by type
+   * @param type - The layout engine type identifier
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object for the dimension or null if type not found or unsupported
+   */
+  static getOptionsForDimensionByType(e, n) {
+    const r = M.get(e);
+    return r ? r.getOptionsForDimension(n) : null;
+  }
+  /**
+   * Get the Zod-based options schema for this layout
+   * @returns The options schema, or an empty object if no schema defined
+   */
+  static getZodOptionsSchema() {
+    return this.zodOptionsSchema ?? {};
+  }
+  /**
+   * Check if this layout has a Zod-based options schema
+   * @returns true if the layout has options defined
+   */
+  static hasZodOptions() {
+    return this.zodOptionsSchema !== void 0 && Object.keys(this.zodOptionsSchema).length > 0;
+  }
+  /**
+   * Get a list of all registered layout types
+   * @returns Array of registered layout type identifiers
+   */
+  static getRegisteredTypes() {
+    return Array.from(M.keys());
+  }
+  /**
+   * Get a layout class by type
+   * @param type - The layout engine type identifier
+   * @returns The layout engine class or null if not found
+   */
+  static getClass(e) {
+    return M.get(e) ?? null;
+  }
+};
+S.setNodePosition = (e, n, r) => {
+  e.setNodePosition(n, r);
+}, S.pin = (e, n) => {
+  e.pin(n);
+}, S.unpin = (e, n) => {
+  e.unpin(n);
+}, S.positions = (e) => e.writablePositions, S.edgeProblems = (e, n) => e.edgeProblems(n), S.addNode = (e, n) => {
+  e.addNode(n);
+}, S.addEdge = (e, n) => {
+  e.addEdge(n);
+}, S.addNodes = (e, n) => {
+  e.addNodes(n);
+}, S.addEdges = (e, n) => {
+  e.addEdges(n);
+}, S.removeNode = (e, n) => {
+  e.removeNode(n);
+}, S.removeEdge = (e, n) => {
+  e.removeEdge(n);
+}, S.attachPositions = (e, n) => {
+  e.attachPositions(n);
+}, pe.honoursWeights = !1, pe.scoped = !1;
+let Se = pe;
+const Un = se.looseObject({
+  scalingFactor: se.number().default(100)
+});
+function Hn(t) {
+  const { previous: e, next: n, report: r } = t;
+  if (e === null || n.nodeCount <= e.nodeCount)
+    return null;
+  const s = re(n.nodeCount), i = r.nodeRemap;
+  for (let c = 0; c < e.nodeCount; c++) {
+    const l = i === null ? c : i[c];
+    if (l === g)
+      return null;
+    En(s, l, !0);
+  }
+  const { src: o, dst: a } = n.edgeList();
+  let u = 0;
+  for (let c = 0; c < n.edgeCount; c++)
+    C(s, o[c]) && C(s, a[c]) && u++;
+  return u === e.edgeCount ? s : null;
+}
+class li extends Se {
+  /**
+   * Create a simple layout engine
+   * @param opts - Configuration options including scalingFactor
+   */
+  constructor(e = {}) {
+    super(), this._nodes = [], this._edges = [], this.stale = !0, this.positions = {}, this.result = null, this.scalingFactor = 100, this.#e = null, this.#t = new Float32Array(0), this.#r = null, this.#n = null, this.isSettled = !0;
+    const n = Un.parse(e);
+    this.scalingFactor = n.scalingFactor;
+  }
+  #e;
+  #t;
+  #r;
+  #n;
+  /**
+   * Get dimension-specific options for simple layouts
+   * @param dimension - The desired dimension (2 or 3)
+   * @returns Options object with dim parameter or null if unsupported
+   */
+  static getOptionsForDimension(e) {
+    return e > this.maxDimensions ? null : { dim: e };
+  }
+  // basic functionality
+  /**
+   * Initialize the layout engine
+   *
+   * Simple layouts compute positions synchronously and don't require initialization.
+   */
+  async init() {
+  }
+  /**
+   * Add a node to the layout and mark positions as stale
+   * @param n - The node to add
+   */
+  addNode(e) {
+    this._nodes.push(e), this.stale = !0;
+  }
+  /**
+   * Add an edge to the layout and mark positions as stale
+   * @param e - The edge to add
+   */
+  addEdge(e) {
+    this._edges.push(e), this.stale = !0;
+  }
+  /**
+   * The graph this run arranges: the element's undirected snapshot, or, for an engine driven
+   * without an element, a graph built from the nodes and edges it was handed, in that order.
+   *
+   * Read it in `doLayout`. Reading it may freeze the element's graph, which is how a node added
+   * since the last run gets a row.
+   * @returns the undirected graph
+   */
+  get graph() {
+    return this.#e ??= this.#s(), this.#e.snapshot;
+  }
+  /**
+   * The coordinates to start this run from, in layout units, `dim` values per row of
+   * the protected `graph`: the element's current coordinates when the run follows an
+   * add, otherwise null. An unplaced row is NaN.
+   * @param dim - components per row
+   * @returns the start rows, or null
+   */
+  startPositions(e) {
+    const { snapshot: n, positions: r } = this.#e ?? this.#s();
+    return this.#n === null || r === null ? null : In(r.view(n.nodeCount), e, this.scalingFactor, null);
+  }
+  /**
+   * The row of a node named in an option, in the protected `graph`.
+   *
+   * A key of an options record is always a string, so a string that misses is tried again as the
+   * number it spells: `{ 1: [...] }` names the node whose id is the number 1.
+   * @param id - the node id, or a record key naming one
+   * @returns the row, or `INVALID_INDEX` when the graph has no such node
+   */
+  rowOfId(e) {
+    const { ids: n } = this.graph, r = n.indexOf(e);
+    return r === g && typeof e == "string" && e.trim() !== "" ? n.indexOf(Number(e)) : r;
+  }
+  /**
+   * {@link SimpleLayoutEngine.rowOfId} for an option that must name a node.
+   * @param id - the node id
+   * @param what - what the option names, for the message
+   * @returns the row
+   * @throws when the graph has no such node
+   */
+  requireRow(e, n) {
+    const r = this.rowOfId(e);
+    if (r === g)
+      throw new Error(`${n} node ${String(e)} is not in the graph`);
+    return r;
+  }
+  /**
+   * Rows of an option that gives coordinates by node id, `dim` values per row of
+   * the protected `graph`; a node the record does not give is NaN.
+   * @param record - the coordinates by node id, in layout units, or null
+   * @param dim - components per row
+   * @returns the rows, or null for no record
+   */
+  rowsOfRecord(e, n) {
+    if (e === null)
+      return null;
+    const r = new Float32Array(n * this.graph.nodeCount).fill(Number.NaN);
+    for (const [s, i] of Object.entries(e)) {
+      const o = this.rowOfId(s);
+      if (o !== g)
+        for (let a = 0; a < n; a++)
+          r[n * o + a] = i[a] ?? 0;
+    }
+    return r;
+  }
+  /**
+   * Hear that the element's graph was frozen again.
+   *
+   * The layout is re-run at the next read. When the freeze only added to the graph this engine
+   * last arranged, and the data is not still loading, the re-run keeps every existing node where
+   * it is (see the class comment). A load is excluded because its chunks are one graph arriving,
+   * not a reader adding to a finished one: a circle whose first chunk was held would be drawn as
+   * two overlapping circles.
+   * @param change - the freeze
+   * @param loading - whether a load is still streaming records in
+   */
+  reload(e, n) {
+    this.stale = !0, this.#n = !n && this.#r !== null && this.#r === e.previous ? Hn(e) : null;
+  }
+  /**
+   * Get the position of a node, computing layout if stale
+   *
+   * The coordinates come from the shared position array, rounded to the f32 it stores. A node
+   * with no row there falls back to what the engine computed, which is every node in an engine
+   * driven by hand.
+   * @param n - The node to get position for
+   * @returns The node's position coordinates
+   */
+  getNodePosition(e) {
+    return this.refresh(), this.publishedOr(e);
+  }
+  /**
+   * Record where the reader has just put a node.
+   *
+   * A static layout has no per-node state a placement could live in, so the placement is
+   * written into the SHARED array, with `"placement"` intent so that it lands even on a pinned
+   * row, and into what the engine computed, so that the next publish of the same answer does
+   * not put the node back.
+   * @param n - the node that moved
+   * @param p - where it moved to
+   */
+  setNodePosition(e, n) {
+    const r = n.z ?? 0;
+    this.writeNodePosition(e, n.x, n.y, r, "placement"), this.positions[e.id] = [n.x / this.scalingFactor, n.y / this.scalingFactor, r / this.scalingFactor];
+    const s = this.#e?.rowOf(e) ?? g;
+    s !== g && 3 * s + 2 < this.#t.length && (this.#t[3 * s] = n.x, this.#t[3 * s + 1] = n.y, this.#t[3 * s + 2] = r);
+  }
+  /**
+   * Get the position of an edge based on its endpoints
+   * @param e - The edge to get position for
+   * @returns The edge's source and destination positions
+   */
+  getEdgePosition(e) {
+    return this.refresh(), {
+      src: this.publishedOr(e.srcNode),
+      dst: this.publishedOr(e.dstNode)
+    };
+  }
+  /**
+   * Copy the computed layout into the shared position array, recomputing it first if it is stale.
+   */
+  publishPositions() {
+    if (this.stale) {
+      this.refresh();
+      return;
+    }
+    this.publishComputed();
+  }
+  // for animated layouts
+  /**
+   * Step the layout animation
+   *
+   * Simple layouts are static and don't animate, so stepping has no effect.
+   */
+  step() {
+  }
+  /**
+   * Take a node out of the layout.
+   *
+   * WITHOUT THIS the engine holds the removed node -- and through it the node's Babylon mesh,
+   * its data record and its endpoints -- for as long as the engine lives, and the frame loop
+   * keeps walking it, so a node the reader deleted still draws at wherever it last was. The
+   * layout is marked stale, so the next read recomputes it without the node.
+   * @param n - the node leaving the graph
+   */
+  removeNode(e) {
+    const n = this._nodes.indexOf(e);
+    n >= 0 && this._nodes.splice(n, 1), this.stale = !0;
+  }
+  /**
+   * The edge half of {@link SimpleLayoutEngine.removeNode}, with the same reason.
+   * @param e - the edge leaving the graph
+   */
+  removeEdge(e) {
+    const n = this._edges.indexOf(e);
+    n >= 0 && this._edges.splice(n, 1), this.stale = !0;
+  }
+  /**
+   * Pin a node in place
+   *
+   * A static layout has nothing of its own to hold still -- it recomputes every position from
+   * scratch -- so the pin is kept by the element's position array instead, and
+   * `writeNodePosition` refuses to move a pinned row.
+   */
+  pin() {
+  }
+  /**
+   * Unpin a node
+   *
+   * The element's position array holds the pin; see {@link SimpleLayoutEngine.pin}.
+   */
+  unpin() {
+  }
+  /**
+   * Keep the arrangement in the array instead of recomputing one: a static layout that was
+   * marked stale by the graph change an undo made would otherwise lay the graph out afresh at
+   * the next read and write over what was restored.
+   */
+  loadArrangement() {
+    this.stale = !1, super.loadArrangement();
+  }
+  // properties
+  /**
+   * Get all nodes in the layout
+   * @returns Iterable of nodes
+   */
+  get nodes() {
+    return this._nodes;
+  }
+  /**
+   * Get all edges in the layout
+   * @returns Iterable of edges
+   */
+  get edges() {
+    return this._edges;
+  }
+  /**
+   * Recompute the layout when it is stale, and publish what it produced.
+   *
+   * A simple layout is computed once and then held, so this is the ONE place the shared array is
+   * filled: every reader below goes through here first, which is why a node added after the last
+   * read still gets a row before anything asks for its coordinates.
+   */
+  refresh() {
+    if (!this.stale)
+      return;
+    if (this.#e = null, this.result = null, this._nodes.length === 0) {
+      this.stale = !1, this.#t = new Float32Array(0);
+      return;
+    }
+    this.doLayout(), this.stale = !1;
+    const e = this.#e;
+    this.#t = this.result === null || e === null ? new Float32Array(0) : $n(this.result, this.scalingFactor, null), this.#r = e?.source ?? null;
+    const n = this.#n;
+    if (this.#n = null, n !== null)
+      for (let r = 0; r < this.#t.length / 3; r++)
+        C(n, r) && this.#t.fill(Number.NaN, 3 * r, 3 * r + 3);
+    this.publishComputed();
+  }
+  /**
+   * Read the graph this run arranges. See the protected `graph`.
+   * @returns the loaded graph
+   */
+  #s() {
+    const e = this._nodes[0]?.parentGraph?.getDataManager?.(), n = e;
+    if (typeof n?.getSnapshot == "function" && typeof n.undirected == "function") {
+      const i = n.getSnapshot(), { snapshot: o } = n.undirected(i);
+      return {
+        snapshot: o,
+        source: i,
+        positions: Lt(e) ?? null,
+        rowOf: (a) => a.index < o.nodeCount ? a.index : g
+      };
+    }
+    const r = new Sn({ directed: !1, addMissingNodes: !0 });
+    for (const i of this._nodes)
+      r.addNode(i.id);
+    for (const i of this._edges)
+      r.addEdge(i.srcId, i.dstId);
+    const s = r.freeze({ label: "static-layout" });
+    return { snapshot: s, source: null, positions: null, rowOf: (i) => s.ids.indexOf(i.id) };
+  }
+  /**
+   * Write the computed answer into the shared array, scaled to scene units.
+   *
+   * A node the layout left unplaced (a NaN row, or no entry in `positions`) is LEFT UNPLACED
+   * rather than published at the origin: the two are indistinguishable once stored, and the
+   * origin is a place a reader would draw at.
+   */
+  publishComputed() {
+    const e = this.#e, n = this.#t;
+    for (const r of this._nodes) {
+      if (e !== null && n.length > 0) {
+        const i = e.rowOf(r);
+        i !== g && 3 * i + 2 < n.length && this.writeNodePosition(r, n[3 * i], n[3 * i + 1], n[3 * i + 2]);
+        continue;
+      }
+      const s = this.positions[r.id];
+      !s || s.length === 0 || this.writeNodePosition(
+        r,
+        s[0] * this.scalingFactor,
+        s[1] * this.scalingFactor,
+        (s[2] ?? 0) * this.scalingFactor
+      );
+    }
+  }
+  /**
+   * A node's published row, or what the engine computed when it has no row of its own.
+   *
+   * The fallback is not a rare path: an engine driven directly -- by a test, or by a host that
+   * keeps no graph -- has nodes whose index is `INVALID_INDEX`, and none of them is ever
+   * published. Both branches produce the same arrangement; only the rounding differs.
+   * @param n - the node, when the caller has one
+   * @returns a fresh coordinate triple; the origin for a node nothing placed
+   */
+  publishedOr(e) {
+    const n = { x: 0, y: 0, z: 0 };
+    if (e === void 0 || this.readNodePosition(e, n))
+      return n;
+    const r = this.#e?.rowOf(e) ?? g, s = this.#t;
+    if (r !== g && 3 * r + 2 < s.length && !Number.isNaN(s[3 * r]))
+      return { x: s[3 * r], y: s[3 * r + 1], z: s[3 * r + 2] };
+    const i = this.positions[e.id];
+    return !i || i.length === 0 ? n : {
+      x: i[0] * this.scalingFactor,
+      y: i[1] * this.scalingFactor,
+      z: (i[2] ?? 0) * this.scalingFactor
+    };
+  }
+}
+function di(t) {
+  return t === 3 ? 3 : 2;
+}
+const Bn = ["forceAtlas2", "fruchtermanReingold", "springElectrical", "release"], Dt = [
+  "pageRank",
+  "sssp",
+  "breadthFirstSearch",
+  "connectedComponents",
+  "weaklyConnectedComponents",
+  "minimumSpanningTree",
+  "hits",
+  "katzCentrality",
+  "eigenvectorCentrality"
+];
+function at(t) {
+  return Dt.includes(t);
+}
+function hi(t) {
+  const e = {
+    kind: t.backend
+  };
+  for (const n of Bn) {
+    const r = t[n];
+    typeof r == "function" && (e[n] = r.bind(t));
+  }
+  return e;
+}
+function Gn(t, e) {
+  const n = {
+    kind: t.backend
+  };
+  for (const r of Dt) {
+    const s = t[r];
+    if (typeof s == "function") {
+      const i = s.bind(t);
+      n[r] = e === void 0 ? i : (...o) => (e(), i(...o));
+    }
+  }
+  return n;
+}
+const Vn = ["auto", "off", "required"], fi = "auto";
+function pi(t) {
+  return typeof t == "string" && Vn.includes(t);
+}
+const ct = "f64", gi = "f32", mi = "acceleration.minNodes", yi = 0, wi = "RTX 4070 SUPER, headless Chromium, 2026-09-27", bi = Object.freeze(
+  {
+    // Above the 50,000-node render ceiling, so not routed to the device today; the kernel's own
+    // resident crossover, because the element cannot hold a graph this large to measure one.
+    breadthFirstSearch: 141e3,
+    // Likewise above the render ceiling, and likewise the kernel's resident crossover.
+    sssp: 107e3,
+    // Measured through the element, and it crosses at the top of what the element can hold.
+    pageRank: 5e4,
+    // Above the render ceiling. Was 50,000, where the device measured 0.51x -- twice as slow.
+    connectedComponents: 132e3,
+    // Interpolated between the kernel's measured 0.72x at 10,000 and 5.71x at 100,000 nodes
+    // against the index-based port; inside the render ceiling, so a graph this large does reach
+    // the device.
+    hits: 15e3,
+    // Likewise, between Katz's 0.36x and 3.66x; eigenvector centrality is costed as the same row.
+    katzCentrality: 28e3,
+    eigenvectorCentrality: 28e3
+  }
+), Wn = 12;
+function vi(t, e = {}) {
+  return (Yn(t) ? qn(t) : Jn(t)).map((r) => {
+    const s = { ...r.meta, ...e.meta?.[r.name] }, i = r.node === null ? Xn(r.name, s, r.failure ?? "the schema could not be converted") : Zn(r.name, r.node, s), o = e.overrides?.[r.name];
+    return o === void 0 ? i : { ...i, ...o };
+  });
+}
+function Yn(t) {
+  return typeof t != "object" || t === null ? !1 : "_zod" in t || "_def" in t;
+}
+function qn(t) {
+  const e = jt(t);
+  if (e === null)
+    return [];
+  const { properties: n } = e;
+  return n === void 0 ? [] : Object.entries(n).map(([r, s]) => ({ name: r, node: Ut(s, e) }));
+}
+function Jn(t) {
+  const e = Object.entries(t), n = {};
+  for (const [i, o] of e)
+    n[i] = o.schema;
+  const r = Kn(n), s = r?.properties;
+  return e.map(([i, o]) => {
+    const a = s?.[i];
+    return r === null || a === void 0 ? {
+      name: i,
+      node: null,
+      failure: "the schema could not be converted to JSON Schema",
+      meta: o.meta
+    } : { name: i, node: Ut(a, r), meta: o.meta };
+  });
+}
+function jt(t) {
+  try {
+    return se.toJSONSchema(t, { io: "input", unrepresentable: "any" });
+  } catch {
+    return null;
+  }
+}
+function Kn(t) {
+  try {
+    return jt(se.object(t));
+  } catch {
+    return null;
+  }
+}
+const ut = "#/$defs/";
+function Ut(t, e) {
+  const n = t.$ref;
+  if (n === void 0 || !n.startsWith(ut))
+    return t;
+  const r = n.slice(ut.length).replaceAll("~1", "/").replaceAll("~0", "~");
+  return e.$defs?.[r] ?? t;
+}
+function Zn(t, e, n) {
+  const r = Ht(e, 0), s = Qn(r), i = {
+    name: t,
+    plainName: n.label ?? Ve(t),
+    technicalName: t,
+    type: s.type
+  }, o = n.description ?? e.description ?? s.node?.description;
+  o !== void 0 && (i.description = o), "default" in e && (i.default = e.default);
+  const a = s.node;
+  if (a !== void 0 && (s.type === "number" || s.type === "integer")) {
+    const c = lt(a.minimum ?? a.exclusiveMinimum), l = lt(a.maximum ?? a.exclusiveMaximum);
+    c !== void 0 && (i.min = c), l !== void 0 && (i.max = l);
+  }
+  const u = n.step ?? a?.multipleOf;
+  return u !== void 0 && (i.step = u), s.values !== void 0 && (i.values = s.values), n.group !== void 0 && (i.group = n.group), n.advanced !== void 0 && (i.advanced = n.advanced), s.unsupportedReason !== void 0 && (i.unsupportedReason = s.unsupportedReason), i;
+}
+function Xn(t, e, n) {
+  const r = {
+    name: t,
+    plainName: e.label ?? Ve(t),
+    technicalName: t,
+    type: "unknown",
+    unsupportedReason: n
+  };
+  return e.description !== void 0 && (r.description = e.description), e.step !== void 0 && (r.step = e.step), e.group !== void 0 && (r.group = e.group), e.advanced !== void 0 && (r.advanced = e.advanced), r;
+}
+function Ht(t, e) {
+  if (e >= Wn)
+    return { arms: [], nullable: !1, unresolvedRef: !0 };
+  if (t.$ref !== void 0)
+    return { arms: [], nullable: !1, unresolvedRef: !0 };
+  const n = t.anyOf ?? t.oneOf;
+  if (n === void 0)
+    return t.type === "null" ? { arms: [], nullable: !0, unresolvedRef: !1 } : { arms: [t], nullable: !1, unresolvedRef: !1 };
+  const r = { arms: [], nullable: !1, unresolvedRef: !1 };
+  for (const s of n) {
+    const i = Ht(s, e + 1);
+    r.arms.push(...i.arms), r.nullable = r.nullable || i.nullable, r.unresolvedRef = r.unresolvedRef || i.unresolvedRef;
+  }
+  return r;
+}
+function Qn(t) {
+  if (t.arms.length === 0)
+    return t.unresolvedRef ? {
+      type: "unknown",
+      unsupportedReason: "the schema is recursive, so it has no single value type"
+    } : {
+      type: "unknown",
+      unsupportedReason: t.nullable ? "the only value the schema accepts is null" : "the schema declares no value type"
+    };
+  const e = tr(t.arms);
+  if (e !== void 0)
+    return { type: "enum", node: t.arms[0], values: e };
+  if (t.arms.length === 1)
+    return er(t.arms[0]);
+  const n = t.arms.map((r) => Bt(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 er(t) {
+  switch (Bt(t)) {
+    case "integer":
+      return { type: "integer", node: t };
+    case "number":
+      return { type: "number", node: t };
+    case "boolean":
+      return { type: "boolean", node: t };
+    case "string":
+      return { type: "string", node: t };
+    case "array":
+      return {
+        type: "unknown",
+        node: t,
+        unsupportedReason: "an array option has no descriptor type; give it one with an override"
+      };
+    case "object":
+      return {
+        type: "unknown",
+        node: t,
+        unsupportedReason: "an object or record option has no descriptor type; give it one with an override"
+      };
+    default:
+      return {
+        type: "unknown",
+        node: t,
+        unsupportedReason: "the Zod construct has no JSON Schema type, so its values cannot be classified"
+      };
+  }
+}
+function tr(t) {
+  const e = [];
+  for (const r of t)
+    if (r.enum !== void 0)
+      e.push(...r.enum);
+    else if ("const" in r)
+      e.push(r.const);
+    else
+      return;
+  if (e.length === 0)
+    return;
+  const n = [];
+  for (const r of e) {
+    if (typeof r != "string" && typeof r != "number" && typeof r != "boolean")
+      return;
+    const s = String(r);
+    n.push({ value: s, label: Ve(s) });
+  }
+  return n;
+}
+function Bt(t) {
+  const { type: e } = t;
+  return typeof e == "string" ? e : Array.isArray(e) && e.length > 0 ? e[0] : "none";
+}
+function lt(t) {
+  if (!(t === Number.MAX_SAFE_INTEGER || t === -Number.MAX_SAFE_INTEGER))
+    return t;
+}
+function Ve(t) {
+  const e = t.replace(/([a-z0-9])([A-Z])/gu, "$1 $2").replace(/[_-]+/gu, " ").trim();
+  return e === "" ? t : e.split(/\s+/u).map((n) => n.charAt(0).toUpperCase() + n.slice(1)).join(" ");
+}
+const me = Ge({
+  kind: "camera",
+  idOf: (t) => t.descriptor.id,
+  descriptorOf: (t) => t.descriptor,
+  implementationOf: (t) => t.compute,
+  builtInIds: () => Mn
+});
+function Oi(t, e) {
+  const n = t.descriptor;
+  if (n === void 0 || typeof n != "object")
+    throw new m({
+      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 m({
+      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 m({
+      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 t.compute != "function")
+    throw new m({
+      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" }
+    });
+  me.register(t, e);
+}
+function Ni() {
+  return me.descriptors();
+}
+function Ai(t) {
+  return me.byId(t);
+}
+function ki() {
+  me.clearForTesting();
+}
+const ye = Ge({
+  kind: "algorithm",
+  idOf: (t) => t.descriptor.key,
+  descriptorOf: (t) => t.descriptor,
+  implementationOf: (t) => t.descriptor,
+  builtInIds: () => Cn
+});
+function nr(t, e) {
+  if (t.descriptor.key !== t.type)
+    throw new m({
+      code: "E_BAD_COMMAND",
+      message: `the algorithm registered as "${t.namespace}:${t.type}" publishes the catalogue key "${t.descriptor.key}". An algorithm has one name: make "descriptor.key" equal "static type".`,
+      source: "registry",
+      details: {
+        kind: "algorithm",
+        field: "descriptor.key",
+        key: t.descriptor.key,
+        type: t.type,
+        namespace: t.namespace
+      }
+    });
+  if (t.descriptor.fields.find((r) => r.name === "runs") !== void 0)
+    throw new m({
+      code: "E_BAD_COMMAND",
+      message: `the algorithm "${t.namespace}:${t.type}" publishes a field named "runs", which is reserved. Name the field something else.`,
+      source: "registry",
+      details: { kind: "algorithm", field: "descriptor.fields", name: "runs", reason: "reserved-field" }
+    });
+  ye.register(t, e);
+}
+function Si() {
+  return ye.descriptors();
+}
+function Ei(t) {
+  return ye.byId(t);
+}
+function Ii() {
+  ye.clearForTesting();
+}
+const rr = {
+  fixed: ["kind", "nodes", "edges", "reading"],
+  rule: ["kind", "where", "reading"],
+  path: ["kind", "nodes", "edges", "directed"]
+}, Gt = ["source", "target", "id", "key", "ordinal", "among"];
+function $(t) {
+  const e = {};
+  for (const n of Object.keys(t).sort())
+    t[n] !== void 0 && (e[n] = t[n]);
+  return e;
+}
+function _(t) {
+  return t === 0 ? 0 : t;
+}
+function Vt(t, e) {
+  return t === e ? 0 : t < e ? -1 : 1;
+}
+function H(t, e) {
+  return typeof t == "number" ? typeof e == "number" ? t - e : -1 : typeof e == "number" ? 1 : Vt(String(t), String(e));
+}
+function Wt(t, e) {
+  for (const n of Gt) {
+    const r = t[n], s = e[n];
+    if (r === void 0 || s === void 0) {
+      if (r !== s)
+        return r === void 0 ? -1 : 1;
+      continue;
+    }
+    const i = H(r, s);
+    if (i !== 0)
+      return i;
+  }
+  return Vt(JSON.stringify(t), JSON.stringify(e));
+}
+function J(t, e) {
+  const n = [...t].sort(e);
+  return n.filter((r, s) => s === 0 || e(n[s - 1], r) !== 0);
+}
+function $i(t) {
+  return J(t, (e, n) => Wt(e, n));
+}
+function Ri(t) {
+  return J(t.map(_), H);
+}
+function We(t) {
+  const e = t, n = { ...e };
+  for (const r of Gt)
+    n[r] = _(e[r]);
+  return $(n);
+}
+function Yt(t) {
+  return J(
+    t.map(We),
+    (e, n) => Wt(e, n)
+  );
+}
+function sr(t) {
+  return t === void 0 || t.length === 0 ? void 0 : Yt(t);
+}
+function ir(t) {
+  if (t === null)
+    return null;
+  if (!Array.isArray(t))
+    return We(t);
+  const e = Yt(t);
+  return e.length === 1 ? e[0] : e;
+}
+const or = /* @__PURE__ */ new Set([
+  "expression",
+  "edges",
+  "range",
+  "categories",
+  "degree",
+  "component",
+  "neighborhood",
+  "threshold"
+]);
+function ar(t) {
+  if (typeof t != "object" || t === null)
+    return t;
+  const e = t;
+  return typeof e.runId == "string" ? e.runId : typeof e.id == "string" ? e.id : t;
+}
+function cr(t) {
+  if (typeof t != "object" || t === null || Array.isArray(t))
+    return t;
+  const e = t, { key: n } = e, r = typeof n == "object" && n !== null && !Array.isArray(n) ? $({ ...n, value: _(n.value) }) : n;
+  return $({ ...e, result: ar(e.result), key: r });
+}
+function Ee(t) {
+  if (typeof t != "object" || t === null || Array.isArray(t))
+    return t;
+  const e = t, { kind: n } = e;
+  if (n === "all" || n === "any")
+    return $({ ...e, of: Array.isArray(e.of) ? e.of.map(Ee) : e.of });
+  if (n === "not")
+    return $({ ...e, of: Ee(e.of) });
+  if (n === "member")
+    return $({ ...e, of: ur(e.of) });
+  if (n === "item")
+    return $({ ...e, item: cr(e.item) });
+  if (typeof n == "string" && or.has(n)) {
+    const r = {};
+    for (const [s, i] of Object.entries(e))
+      r[s] = s === "seeds" && Array.isArray(i) ? i.map(_) : _(i);
+    return $(r);
+  }
+  return t;
+}
+function ur(t) {
+  if (typeof t != "object" || t === null || Array.isArray(t))
+    return t;
+  const e = t;
+  return ie(e, ["define"]) && ie(e, ["nodes"]) ? t : typeof e.define == "object" && e.define !== null ? { define: qt(e.define) } : Array.isArray(e.nodes) ? { nodes: J(e.nodes.map(_), H) } : t;
+}
+function ie(t, e) {
+  return Object.keys(t).some((n) => t[n] !== void 0 && !e.includes(n));
+}
+function qt(t) {
+  const e = t;
+  switch (t.kind) {
+    case "fixed": {
+      const n = ie(e, rr.fixed), { reading: r, edges: s } = t, i = t.nodes.map(_);
+      return $({
+        ...e,
+        nodes: n ? i : J(i, H),
+        edges: n ? s?.map(We) : sr(s),
+        reading: r === "clipped" ? "listed" : r
+      });
+    }
+    case "rule": {
+      const n = Ee(t.where), r = typeof n == "object" && n.kind === "expression" && !ie(n, ["kind", "where"]) ? n.where : n;
+      return $({ ...e, where: r });
+    }
+    case "path": {
+      const n = t.edges?.map(ir);
+      return $({
+        ...e,
+        nodes: t.nodes.map(_),
+        edges: n === void 0 || n.length === 0 ? void 0 : n,
+        directed: t.directed === !1 ? void 0 : t.directed
+      });
+    }
+    default:
+      return t;
+  }
+}
+const Ie = { a: 0, b: 0 }, Ye = 2166136261, oe = 16777619, qe = 461845907, ae = 2246822507, $e = 35, lr = 36, Jt = 105, dr = 107, Kt = 111, ce = new DataView(new ArrayBuffer(8)), Zt = new Float64Array(ce.buffer), Xt = new Uint32Array(ce.buffer), W = new Float64Array(4), Qt = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
+let j = Ye, U = qe;
+function F() {
+  j = Ye, U = qe;
+}
+function R(t) {
+  j = Math.imul(j ^ t, oe) >>> 0, U = Math.imul(U ^ t, ae) >>> 0;
+}
+function O(t) {
+  if (R($e), !Qt) {
+    ce.setFloat64(0, t === 0 ? 0 : t, !0);
+    for (let r = 0; r < 8; r++)
+      R(ce.getUint8(r));
+    return;
+  }
+  Zt[0] = t === 0 ? 0 : t;
+  let e = j, n = U;
+  for (let r = 0; r < 2; r++) {
+    const s = Xt[r];
+    for (let i = 0; i < 32; i += 8) {
+      const o = s >>> i & 255;
+      e = Math.imul(e ^ o, oe) >>> 0, n = Math.imul(n ^ o, ae) >>> 0;
+    }
+  }
+  j = e, U = n;
+}
+function Je(t) {
+  R(lr);
+  for (let e = 0; e < t.length; e++)
+    R(t.charCodeAt(e));
+}
+function ue(t) {
+  typeof t == "number" ? O(t) : Je(t);
+}
+function le(t) {
+  let e = t ^ t >>> 16;
+  return e = Math.imul(e, 2246822507), e ^= e >>> 13, e = Math.imul(e, 3266489909), (e ^ e >>> 16) >>> 0;
+}
+function T() {
+  return { a: le(j), b: le(U) };
+}
+function Re(t) {
+  return F(), ue(t), T();
+}
+function de(t, e) {
+  if (!Qt)
+    return F(), O(t.a), O(t.b), O(e.a), O(e.b), T();
+  let n = Ye, r = qe;
+  W[0] = t.a, W[1] = t.b, W[2] = e.a, W[3] = e.b;
+  for (let s = 0; s < 4; s++) {
+    Zt[0] = W[s], n = Math.imul(n ^ $e, oe) >>> 0, r = Math.imul(r ^ $e, ae) >>> 0;
+    for (let i = 0; i < 2; i++) {
+      const o = Xt[i];
+      for (let a = 0; a < 32; a += 8) {
+        const u = o >>> a & 255;
+        n = Math.imul(n ^ u, oe) >>> 0, r = Math.imul(r ^ u, ae) >>> 0;
+      }
+    }
+  }
+  return { a: le(n), b: le(r) };
+}
+function hr(t) {
+  if (F(), t.id !== void 0)
+    R(Jt), ue(t.id);
+  else if (t.key !== void 0)
+    R(dr), ue(t.key);
+  else if (t.ordinal !== void 0 && t.among !== void 0)
+    R(Kt), O(t.ordinal), O(t.among);
+  else
+    throw new Error("an edge member needs an id, a key, or an ordinal with among");
+  return T();
+}
+function Ke(t) {
+  return Re(t);
+}
+function en(t, e) {
+  const n = Re(t.source), r = Re(t.target), s = e ? de(n, r) : Me(n, r);
+  return de(s, hr(t));
+}
+function fr(t, e, n, r, s, i) {
+  const o = n ? de(t, e) : { a: t.a + e.a >>> 0, b: t.b + e.b >>> 0 };
+  let a;
+  return r !== void 0 ? (F(), R(Jt), ue(r), a = T()) : ((s !== dt || i !== ht) && (F(), R(Kt), O(s), O(i), dt = s, ht = i, ft = T()), a = ft), de(o, a);
+}
+let dt = -1, ht = -1, ft = Ie;
+function Me(t, e) {
+  return { a: t.a + e.a >>> 0, b: t.b + e.b >>> 0 };
+}
+function Mi(t, e) {
+  return { a: t.a - e.a >>> 0, b: t.b - e.b >>> 0 };
+}
+function we(t) {
+  return t.a.toString(16).padStart(8, "0") + t.b.toString(16).padStart(8, "0");
+}
+function he(t, e) {
+  return { count: t, sum: we(e) };
+}
+function Ci(t, e, n) {
+  const r = {
+    ...n === void 0 || n.count === 0 ? {} : { edges: he(n.count, n.sum) },
+    kind: "fixed",
+    nodes: he(e.count, e.sum),
+    reading: t
+  };
+  return F(), Je(JSON.stringify(r)), `r1:${we(T())}`;
+}
+function _i(t) {
+  const e = qt(t);
+  let n = e;
+  if (e.kind === "fixed") {
+    let r = Ie;
+    for (const i of e.nodes)
+      r = Me(r, Ke(i));
+    const s = { ...e, nodes: he(e.nodes.length, r) };
+    if (e.edges !== void 0) {
+      let i = Ie;
+      for (const o of e.edges)
+        i = Me(i, en(o, !0));
+      s.edges = he(e.edges.length, i);
+    }
+    n = s;
+  }
+  return F(), Je(JSON.stringify(n)), `r1:${we(T())}`;
+}
+function Fi(t, e) {
+  return F(), O(t.count), O(t.sum.a), O(t.sum.b), O(e.count), O(e.sum.a), O(e.sum.b), `d1:${we(T())}`;
+}
+function pr(t) {
+  return String(t);
+}
+function gr(t) {
+  if (!/^\d+$/.test(t))
+    return g;
+  const e = Number(t);
+  return Number.isSafeInteger(e) ? e : g;
+}
+function mr(t, e) {
+  const n = gr(e);
+  return n === g ? g : t.edgeIndexOf(n);
+}
+function Ti() {
+  return { next: 0 };
+}
+function tn(t) {
+  return `graphty:e${t}`;
+}
+function Pi(t, e, n) {
+  switch (t) {
+    case "keep":
+      return { kind: "add" };
+    case "error":
+      return { kind: "refuse" };
+    case "first":
+      return { kind: "drop" };
+    case "sum":
+      return { kind: "merge", weight: e + n, replaceRecord: !1 };
+    case "min":
+      return { kind: "merge", weight: Math.min(e, n), replaceRecord: !1 };
+    case "max":
+      return { kind: "merge", weight: Math.max(e, n), replaceRecord: !1 };
+    default:
+      return { kind: "merge", weight: n, replaceRecord: !0 };
+  }
+}
+const Ce = "graphty.edgeId", X = {
+  /** Node: `hashNodeId` of the node id, two uint32 lanes. */
+  nodeHash: "graphty.nodeHash",
+  /** Edge: `hashEdgeMember` of the edge's stable identity, two uint32 lanes. */
+  edgeHash: "graphty.edgeHash",
+  /** Edge: its position among its pair's surviving edges in its load; -1 for a session edge. */
+  edgeOrdinal: "graphty.edgeOrdinal",
+  /** Edge: its pair's surviving edge count in its load; -1 for a session edge. */
+  edgeAmong: "graphty.edgeAmong"
+}, yr = "graphty.edgePairsOrdered";
+function wr(t, e, n, r, s) {
+  const i = t.length, o = new Uint32Array(i), a = new Uint32Array(i);
+  let u = 0;
+  for (let p = 0; p < i; p++) {
+    const [I, B] = e.endpoints(t[p]), G = !n && B < I;
+    o[p] = G ? B : I, a[p] = G ? I : B, u = Math.max(u, o[p] + 1, a[p] + 1);
+  }
+  const { perm: c, bytes: l } = br(o, a, u);
+  t.byteLength + o.byteLength + a.byteLength + l;
+  const d = e.hashOf === void 0 ? (p) => Ke(e.idOf(p)) : e.hashOf.bind(e);
+  let h = 0, f = -1, N = { a: 0, b: 0 };
+  for (; h < i; ) {
+    const p = c[h];
+    let I = h + 1;
+    for (; I < i && o[c[I]] === o[p] && a[c[I]] === a[p]; )
+      I++;
+    o[p] !== f && (f = o[p], N = d(f));
+    const B = d(a[p]), G = I - h;
+    for (let Z = h; Z < I; Z++) {
+      const nt = c[Z], rt = Z - h;
+      s(
+        t[nt],
+        rt,
+        G,
+        fr(N, B, n, r(nt), rt, G)
+      );
+    }
+    h = I;
+  }
+}
+function br(t, e, n) {
+  const r = t.length;
+  if (n > 4 * r) {
+    const u = new Uint32Array(r);
+    for (let c = 0; c < r; c++)
+      u[c] = c;
+    return u.sort((c, l) => t[c] - t[l] || e[c] - e[l] || c - l), { perm: u, bytes: u.byteLength };
+  }
+  const s = new Uint32Array(n + 1), i = new Uint32Array(r), o = new Uint32Array(r), a = (u, c, l) => {
+    s.fill(0);
+    for (let d = 0; d < r; d++)
+      s[u[d] + 1]++;
+    for (let d = 0; d < n; d++)
+      s[d + 1] += s[d];
+    for (let d = 0; d < r; d++) {
+      const h = c === null ? d : c[d];
+      l[s[u[h]]++] = h;
+    }
+  };
+  return a(e, null, i), a(t, i, o), { perm: o, bytes: s.byteLength + i.byteLength + o.byteLength };
+}
+function xi(t, e, n, r, s) {
+  const [i, o] = t.endpoints(e);
+  return en(
+    { source: t.idOf(i), target: t.idOf(o), id: r ?? tn(n) },
+    s
+  );
+}
+function nn(t) {
+  const e = t.graph.typed(yr, "u8");
+  return e === null ? t.directed : e.data[0] === 1;
+}
+function zi(t, e) {
+  if (e || typeof t != "object" || t === null)
+    return t;
+  const { source: n, target: r } = t, s = (i) => typeof i == "string" || typeof i == "number";
+  return !s(n) || !s(r) || H(r, n) >= 0 ? t : { ...t, source: r, target: n };
+}
+function vr(t) {
+  return {
+    endpoints: (e) => [t.edgeSource(e), t.edgeTarget(e)],
+    idOf: (e) => t.ids.idOf(e)
+  };
+}
+const pt = /* @__PURE__ */ new WeakMap();
+function Or(t) {
+  const e = t.nodes.typed(X.nodeHash, "u32"), n = t.edges.typed(X.edgeHash, "u32"), r = t.edges.typed(X.edgeOrdinal, "i32"), s = t.edges.typed(X.edgeAmong, "i32");
+  if (e !== null && n !== null && r !== null && s !== null)
+    return {
+      nodeHash: e.data,
+      edgeHash: n.data,
+      edgeOrdinal: r.data,
+      edgeAmong: s.data
+    };
+  let i = pt.get(t);
+  return i === void 0 && (i = Nr(t), pt.set(t, i)), i;
+}
+function Nr(t) {
+  const e = new Uint32Array(2 * t.nodeCount);
+  for (let o = 0; o < t.nodeCount; o++) {
+    const { a, b: u } = Ke(t.ids.idOf(o));
+    e[2 * o] = a, e[2 * o + 1] = u;
+  }
+  const n = new Uint32Array(2 * t.edgeCount), r = new Int32Array(t.edgeCount), s = new Int32Array(t.edgeCount), i = new Uint32Array(t.edgeCount);
+  for (let o = 0; o < i.length; o++)
+    i[o] = o;
+  return wr(
+    i,
+    vr(t),
+    nn(t),
+    () => {
+    },
+    (o, a, u, c) => {
+      r[o] = a, s[o] = u, n[2 * o] = c.a, n[2 * o + 1] = c.b;
+    }
+  ), { nodeHash: e, edgeHash: n, edgeOrdinal: r, edgeAmong: s };
+}
+function Li(t, e, n) {
+  let r = t.ids.idOf(t.edgeSource(e)), s = t.ids.idOf(t.edgeTarget(e));
+  if (!nn(t) && H(s, r) < 0 && ([r, s] = [s, r]), n !== void 0)
+    return { source: r, target: s, id: n };
+  const { edgeOrdinal: i, edgeAmong: o } = Or(t), a = i[e];
+  if (a >= 0)
+    return { source: r, target: s, ordinal: a, among: o[e] };
+  const u = t.edges.typed(Ce, "u32");
+  if (u === null || !u.isSet(e))
+    throw new Error(`edge ${e} has neither an ordinal nor a counter to mint an id from`);
+  return { source: r, target: s, id: tn(u.data[e]) };
+}
+const Ar = 256 * 1024 * 1024, kr = 1.5, gt = /* @__PURE__ */ new WeakMap();
+let Sr = 1;
+function Er(t) {
+  if (t === null)
+    return 0;
+  let e = gt.get(t);
+  return e === void 0 && (e = Sr++, gt.set(t, e)), e;
+}
+function Ir(t, e) {
+  let n = 2166136261, r = 16777619 ^ t.length;
+  for (const s of [t, e]) {
+    for (let i = 0; i < s.length; i++) {
+      const o = s[i];
+      n = Math.imul(n ^ o, 16777619), r = Math.imul(r ^ (o >>> 16 | o << 16), 16777619) ^ i;
+    }
+    n = Math.imul(n ^ s.length, 16777619);
+  }
+  return `${(n >>> 0).toString(16)}${(r >>> 0).toString(16)}`;
+}
+function mt(t, e) {
+  if (t === e)
+    return !0;
+  if (t.length !== e.length)
+    return !1;
+  for (let n = 0; n < t.length; n++)
+    if (t[n] !== e[n])
+      return !1;
+  return !0;
+}
+function yt(t) {
+  const e = /* @__PURE__ */ new Set(), n = [...t];
+  let r = 0;
+  for (; n.length > 0; ) {
+    const s = n.pop();
+    if (!(s === null || typeof s != "object" || e.has(s))) {
+      if (e.add(s), ArrayBuffer.isView(s)) {
+        r += s.byteLength;
+        continue;
+      }
+      if (!(s instanceof ArrayBuffer)) {
+        if (s instanceof Map)
+          for (const [i, o] of s)
+            n.push(i, o);
+        else if (s instanceof Set)
+          for (const i of s)
+            n.push(i);
+        for (const i of Reflect.ownKeys(s)) {
+          const o = Object.getOwnPropertyDescriptor(s, i);
+          o !== void 0 && "value" in o && n.push(o.value);
+        }
+      }
+    }
+  }
+  return r;
+}
+function wt(t) {
+  return t.byteLength({ columns: !0, ids: !0 });
+}
+class $r {
+  /**
+   * An empty cache.
+   * @param options - The release hook and, for tests, the byte bound.
+   * @param options.release - Frees an accelerator's device buffers for a snapshot nothing uses.
+   * @param options.limit - A fixed byte bound instead of max(256 MB, 1.5 x the full snapshot).
+   */
+  constructor(e = {}) {
+    this.options = e, this.entries = /* @__PURE__ */ new Map(), this.draining = /* @__PURE__ */ new Set(), this.reservations = /* @__PURE__ */ new Map(), this.waiters = [], this.fullBytes = 0, this.disposed = !1;
+  }
+  /**
+   * The byte bound now.
+   * @returns The bound.
+   */
+  get bound() {
+    return this.options.limit ?? Math.max(Ar, Math.ceil(kr * this.fullBytes));
+  }
+  /**
+   * The bytes the live entries hold, draining ones included.
+   * @returns The byte count.
+   */
+  get bytes() {
+    return yt([...this.live()].map(vt));
+  }
+  /**
+   * Every live entry, draining ones included, least recently used first. For the accounting test.
+   * @returns The entries.
+   */
+  list() {
+    return [...this.live()].map((e) => ({
+      key: e.key,
+      snapshot: e.snapshot,
+      edgeRemap: e.edgeRemap,
+      nodeOrigin: e.nodeOrigin,
+      nodes: e.nodes,
+      edges: e.edges,
+      held: e.holders.size > 0,
+      marked: e.marked
+    }));
+  }
+  /**
+   * A cached input, held for a run on a hit.
+   * @param holder - The run.
+   * @param membership - What it is derived for.
+   * @param orientation - The orientation.
+   * @param simplify - The merge policy.
+   * @returns The input, or undefined on a miss.
+   */
+  get(e, n, r, s) {
+    this.sync(n);
+    const i = bt(n, r, s), o = this.entries.get(i);
+    if (!(o === void 0 || !mt(o.nodes, n.nodes) || !mt(o.edges, n.edges)))
+      return this.entries.delete(i), this.entries.set(i, o), o.holders.add(e), o;
+  }
+  /**
+   * Cache an input a run derived, held for it, then evict unheld entries past the bound.
+   * @param holder - The run.
+   * @param membership - What it was derived for.
+   * @param orientation - The orientation.
+   * @param simplify - The merge policy.
+   * @param input - The derived input.
+   * @param full - The full snapshot it was derived from, whose bytes set the bound.
+   * @returns The input.
+   */
+  put(e, n, r, s, i, o) {
+    this.sync(n), this.fullBytes = wt(o);
+    const a = bt(n, r, s), u = this.entries.get(a);
+    u !== void 0 && (this.entries.delete(a), this.evictEntry(u));
+    const c = {
+      ...i,
+      key: a,
+      serial: n.serial,
+      store: n.store,
+      nodes: n.nodes,
+      edges: n.edges,
+      holders: /* @__PURE__ */ new Set([e]),
+      marked: this.disposed
+    };
+    return this.disposed ? this.draining.add(c) : (this.entries.set(a, c), this.shrink()), c;
+  }
+  /**
+   * Reserve room for a run's derivation before it starts. Evicts unheld entries to make room;
+   * waits while a DIFFERENT run holds or reserves what would free it; refuses `E_TOO_LARGE`
+   * when nothing else holds anything and it still does not fit. A run that already holds an
+   * input is admitted at once: it never waits on itself.
+   * @param holder - The run.
+   * @param estimate - The bytes its derivation is expected to take.
+   * @param full - The full snapshot, whose bytes set the bound.
+   * @param signal - Aborts the wait.
+   * @returns Resolves once the run may derive.
+   */
+  async reserve(e, n, r, s) {
+    for (this.fullBytes = wt(r); ; ) {
+      if (s?.throwIfAborted(), this.holds(e))
+        return;
+      const i = this.bound - this.pending(e) - n;
+      if (this.shrink(i), this.bytes <= i) {
+        this.reservations.set(e, n);
+        return;
+      }
+      if (!this.othersHold(e))
+        throw new m({
+          code: "E_TOO_LARGE",
+          message: `A scoped run needs about ${String(n)} bytes for its input, and the derived-input cache holds at most ${String(this.bound)}.`,
+          source: "run",
+          details: { reason: "derived-input", estimate: n, bound: this.bound }
+        });
+      await this.nextRelease(s);
+    }
+  }
+  /**
+   * A run published or aborted: it lets go of every input it held and its reservation. A marked
+   * input with no holder left is released; waiting runs try again.
+   * @param holder - The run.
+   */
+  releaseHolder(e) {
+    this.reservations.delete(e);
+    for (const n of [...this.live()])
+      n.holders.delete(e) && n.holders.size === 0 && n.marked && this.free(n);
+    this.shrink(), this.wake();
+  }
+  /** The graph froze: every entry is over a snapshot that has gone. */
+  freeze() {
+    for (const e of [...this.entries.values()])
+      this.entries.delete(e.key), this.evictEntry(e);
+    this.wake();
+  }
+  /** The graph is being torn down: release what nothing holds, mark the rest, cache nothing more. */
+  dispose() {
+    this.disposed = !0, this.freeze();
+  }
+  /**
+   * Mark every entry over another snapshot or store than this membership's.
+   * @param membership - The membership now being asked for.
+   */
+  sync(e) {
+    for (const n of [...this.entries.values()])
+      (n.serial !== e.serial || n.store !== e.store) && (this.entries.delete(n.key), this.evictEntry(n));
+  }
+  /**
+   * Evict unheld entries, least recently used first, until the bytes fit.
+   * @param budget - The bytes to fit in; the bound by default.
+   */
+  shrink(e = this.bound) {
+    for (const n of [...this.entries.values()]) {
+      if (this.bytes <= e)
+        return;
+      n.holders.size === 0 && (this.entries.delete(n.key), this.evictEntry(n));
+    }
+  }
+  /**
+   * Take an entry out of the cache: released at once when unheld, else marked and drained.
+   * @param entry - It.
+   */
+  evictEntry(e) {
+    e.marked = !0, e.holders.size === 0 ? this.free(e) : this.draining.add(e);
+  }
+  /**
+   * Release an entry's snapshot, unless another live entry still reaches the same one.
+   * @param entry - It.
+   */
+  free(e) {
+    this.draining.delete(e);
+    for (const n of this.live())
+      if (n !== e && n.snapshot === e.snapshot)
+        return;
+    this.options.release?.(e.snapshot);
+  }
+  /**
+   * Every live entry: cached and draining.
+   * @yields Each entry.
+   */
+  *live() {
+    yield* this.entries.values(), yield* this.draining;
+  }
+  /**
+   * Whether a run holds anything.
+   * @param holder - The run.
+   * @returns True when it does.
+   */
+  holds(e) {
+    for (const n of this.live())
+      if (n.holders.has(e))
+        return !0;
+    return !1;
+  }
+  /**
+   * Whether a run other than this one holds an input or a reservation.
+   * @param holder - The run asking.
+   * @returns True when another does.
+   */
+  othersHold(e) {
+    for (const n of this.reservations.keys())
+      if (n !== e)
+        return !0;
+    for (const n of this.live())
+      for (const r of n.holders)
+        if (r !== e)
+          return !0;
+    return !1;
+  }
+  /**
+   * The bytes other runs reserved and have not yet derived.
+   * @param holder - The run asking, left out.
+   * @returns The byte count.
+   */
+  pending(e) {
+    let n = 0;
+    for (const [r, s] of this.reservations) {
+      if (r === e)
+        continue;
+      const i = yt([...this.live()].filter((o) => o.holders.has(r)).map(vt));
+      n += Math.max(0, s - i);
+    }
+    return n;
+  }
+  /**
+   * Resolves the next time a run lets go or the graph freezes.
+   * @param signal - Rejects the wait when aborted.
+   * @returns The wait.
+   */
+  nextRelease(e) {
+    return new Promise((n, r) => {
+      const s = () => {
+        this.waiters = this.waiters.filter((o) => o !== i), r(
+          e?.reason instanceof Error ? e.reason : new DOMException("The run was cancelled.", "AbortError")
+        );
+      }, i = () => {
+        e?.removeEventListener("abort", s), n();
+      };
+      this.waiters.push(i), e?.addEventListener("abort", s, { once: !0 });
+    });
+  }
+  /** Let every waiting run try again. */
+  wake() {
+    const e = this.waiters;
+    this.waiters = [];
+    for (const n of e)
+      n();
+  }
+}
+function bt(t, e, n) {
+  return `${String(Er(t.store))}:${String(t.serial)}:${Ir(t.nodes, t.edges)}:${e}:${n}`;
+}
+function vt(t) {
+  return [t.snapshot, t.edgeRemap, t.nodeOrigin, t.nodes, t.edges];
+}
+const fe = /* @__PURE__ */ new WeakMap();
+function Ze(t) {
+  return t.constructor.scopeInput === "subgraph";
+}
+function Rr(t) {
+  return Ze(t) ? fe.get(t) : void 0;
+}
+function Mr(t) {
+  return fe.get(t)?.scope() ?? null;
+}
+function _e(t) {
+  return t === "undirected" ? "undirected" : "declared";
+}
+function rn(t, e) {
+  if (e === null)
+    return t;
+  if (t === null)
+    return e;
+  const n = new Uint32Array(t.length);
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r];
+    n[r] = s === g ? g : e[s];
+  }
+  return n;
+}
+function Cr(t, e, n, r) {
+  const s = n === "undirected" ? t.undirected(e) : null, i = s === null ? e : s.snapshot, o = r !== "none" && i.flags.multigraph ? i.simplified({ weights: r }) : null;
+  return {
+    snapshot: o === null ? i : o.snapshot,
+    edgeRemap: rn(s?.edgeRemap ?? null, o?.edgeRemap ?? null),
+    nodeOrigin: null
+  };
+}
+function Fe(t, e) {
+  return {
+    snapshot: e.snapshot,
+    edgeRemap: rn(t.edgeRemap, e.edgeRemap),
+    nodeOrigin: t.nodeOrigin
+  };
+}
+function _r(t, e) {
+  const n = e.inducedSubgraph({ mask: t.nodes }), r = n.edgeRemap, s = re(n.snapshot.edgeCount);
+  let i = 0;
+  const { edges: o } = t;
+  for (let u = 0; u < o.length; u++) {
+    let c = o[u];
+    for (; c !== 0; ) {
+      const l = c & -c, d = u * 32 + (31 - Math.clz32(l));
+      if (c ^= l, d >= e.edgeCount)
+        continue;
+      const h = r === null ? d : r[d];
+      h !== g && (s[h >>> 5] |= 1 << (h & 31), i++);
+    }
+  }
+  const a = { snapshot: n.snapshot, edgeRemap: r, nodeOrigin: n.nodeOrigin };
+  return i === n.snapshot.edgeCount ? a : Fe(a, n.snapshot.filterEdges(s));
+}
+function Fr(t, e, n, r, s) {
+  const { inputs: i, holder: o } = t, a = i.get(o, e, r, s);
+  if (a !== void 0)
+    return a;
+  const u = i.get(o, e, "declared", "none") ?? i.put(o, e, "declared", "none", _r(e, n), n);
+  let c = u;
+  return r === "undirected" && c.snapshot.directed && (c = Fe(c, c.snapshot.toUndirected())), s !== "none" && c.snapshot.flags.multigraph && (c = Fe(c, c.snapshot.simplified({ weights: s }))), c === u ? u : i.put(o, e, r, s, c, n);
+}
+function sn(t, e, n, r) {
+  const s = t.getSnapshot(), i = n?.simplify ?? "sum", o = r?.scope() ?? null;
+  if (o !== null && o.graph !== s)
+    throw new Error("A run's scope was resolved against a snapshot that is no longer the graph.");
+  const a = o?.resolution, u = a === void 0 || a.nodeCount === s.nodeCount && a.edgeCount === s.edgeCount ? null : a;
+  let c = null, l = u?.nodes ?? null, d = u?.edges ?? null;
+  const h = {
+    graph: s,
+    whole: u === null,
+    nodeCount: u?.nodeCount ?? s.nodeCount,
+    edgeCount: u?.edgeCount ?? s.edgeCount,
+    derived() {
+      return c ??= u === null || r === void 0 ? Cr(t, s, e, i) : Fr(r, u, s, e, i), c;
+    },
+    subgraph() {
+      return h.derived().snapshot;
+    }
+  };
+  return Object.defineProperties(h, {
+    nodes: {
+      enumerable: !0,
+      get: () => (l ??= re(s.nodeCount, !0), l)
+    },
+    edges: {
+      enumerable: !0,
+      get: () => (d ??= re(s.edgeCount, !0), d)
+    }
+  }), h;
+}
+function Di(t) {
+  const { graph: e, nodes: n, whole: r } = t, s = [];
+  for (let i = 0; i < e.nodeCount; i++)
+    (r || C(n, i)) && s.push(e.ids.idOf(i));
+  return s;
+}
+function ji(t) {
+  const { graph: e, edges: n, whole: r } = t, s = e.edges.typed(Ce, "u32");
+  if (s === null)
+    throw new Error(`The graph carries no "${Ce}" column to name its edges by.`);
+  const { src: i, dst: o } = e.edgeList(), a = [];
+  for (let u = 0; u < e.edgeCount; u++)
+    (r || C(n, u)) && a.push({
+      id: pr(s.data[u]),
+      row: u,
+      source: e.ids.idOf(i[u]),
+      target: e.ids.idOf(o[u])
+    });
+  return a;
+}
+const Te = /* @__PURE__ */ new WeakMap();
+function Tr(t) {
+  let e = Te.get(t);
+  return e === void 0 && (e = new $r({
+    release: (n) => {
+      const { accelerator: r } = t.acceleration, s = r?.release;
+      if (typeof s == "function")
+        try {
+          s.call(r, n);
+        } catch (i) {
+          console.warn("graphty: an accelerator threw while releasing a derived input", i);
+        }
+    }
+  }), Te.set(t, e)), e;
+}
+function Ui(t) {
+  return Te.get(t);
+}
+function Pr(t) {
+  const { graph: e, resolution: n } = t, r = e.nodeCount + e.edgeCount, s = e.byteLength({ columns: !0, ids: !0 });
+  return r === 0 ? 0 : Math.ceil(s * (n.nodeCount + n.edgeCount) / r);
+}
+async function Hi(t, e, n, r, s) {
+  const i = Tr(e), o = {};
+  fe.set(t, { inputs: i, holder: o, scope: n });
+  try {
+    if (Ze(t)) {
+      const a = n();
+      a !== null && (a.resolution.nodeCount !== a.graph.nodeCount || a.resolution.edgeCount !== a.graph.edgeCount) && await i.reserve(o, Pr(a), a.graph, r);
+    }
+    return await s();
+  } finally {
+    fe.delete(t), i.releaseHolder(o);
+  }
+}
+class k extends Error {
+  /**
+   * Creates an option validation error
+   * @param optionKey - The key of the option that failed validation
+   * @param message - The validation error message
+   */
+  constructor(e, n) {
+    super(`Option '${e}': ${n}`), this.optionKey = e, this.name = "OptionValidationError";
+  }
+}
+function xr(t, e, n) {
+  if (e == null) {
+    if (n.required)
+      throw new k(t, "is required but was not provided");
+    return;
+  }
+  switch (n.type) {
+    case "number":
+      Ot(t, e, n, !1);
+      break;
+    case "integer":
+      Ot(t, e, n, !0);
+      break;
+    case "boolean":
+      if (typeof e != "boolean")
+        throw new k(t, `must be a boolean, got ${typeof e}`);
+      break;
+    case "string":
+      if (typeof e != "string")
+        throw new k(t, `must be a string, got ${typeof e}`);
+      break;
+    case "select":
+      zr(t, e, n);
+      break;
+    case "nodeId":
+      if (typeof e != "string" && typeof e != "number")
+        throw new k(t, `must be a string or number (node ID), got ${typeof e}`);
+      break;
+    default:
+      throw new k(t, `has unknown type '${n.type}'`);
+  }
+}
+function Ot(t, e, n, r) {
+  if (typeof e != "number")
+    throw new k(t, `must be a number, got ${typeof e}`);
+  if (Number.isNaN(e))
+    throw new k(t, "must not be NaN");
+  if (!Number.isFinite(e))
+    throw new k(t, "must be finite");
+  if (r && !Number.isInteger(e))
+    throw new k(t, `must be an integer, got ${e}`);
+  if (n.min !== void 0 && e < n.min)
+    throw new k(t, `must be >= ${n.min}, got ${e}`);
+  if (n.max !== void 0 && e > n.max)
+    throw new k(t, `must be <= ${n.max}, got ${e}`);
+}
+function zr(t, e, n) {
+  if (!n.options || n.options.length === 0)
+    throw new k(t, "is a select type but has no options defined");
+  if (!n.options.map((s) => s.value).includes(e)) {
+    const s = n.options.map((i) => `'${String(i.value)}'`).join(", ");
+    throw new k(t, `must be one of [${s}], got '${String(e)}'`);
+  }
+}
+function Lr(t, e) {
+  const n = {};
+  for (const [r, s] of Object.entries(t)) {
+    const o = e?.[r] ?? s.default;
+    xr(r, o, s), n[r] = o;
+  }
+  return n;
+}
+function Bi(t) {
+  return t;
+}
+function Dr(t, e, n = sn(t, _e(e))) {
+  return jr(n.subgraph(), e);
+}
+function Gi(t) {
+  const e = t.getSnapshot();
+  return e.flags.multigraph ? e.edgeCount - e.simplified({ weights: "sum" }).snapshot.edgeCount : 0;
+}
+function jr(t, e) {
+  const n = new Fn({
+    directed: e !== "undirected"
+  }), { ids: r } = t;
+  for (let a = 0; a < t.nodeCount; a++)
+    n.addNode(r.idOf(a));
+  const { src: s, dst: i, weights: o } = t.edgeList();
+  for (let a = 0; a < t.edgeCount; a++) {
+    const u = r.idOf(s[a]), c = r.idOf(i[a]), l = o === null ? 1 : o[a];
+    n.addEdge(u, c, l);
+  }
+  return n;
+}
+const Q = new xt("algorithm"), Nt = /* @__PURE__ */ new WeakMap();
+function Ur(t, e, n) {
+  if (t.scopeInput !== void 0 && t.scopeInput !== e)
+    throw new m({
+      code: "E_BAD_COMMAND",
+      message: `the algorithm registered as "${n}" publishes scopeInput "${t.scopeInput}" and its class declares "${e}". Declare it once, as "static scopeInput", and leave it out of the descriptor.`,
+      source: "registry",
+      details: {
+        kind: "algorithm",
+        field: "descriptor.scopeInput",
+        key: t.key,
+        declared: e,
+        published: t.scopeInput
+      }
+    });
+  let r = Nt.get(t);
+  r === void 0 && (r = /* @__PURE__ */ new Map(), Nt.set(t, r));
+  let s = r.get(e);
+  return s === void 0 && (s = { ...t, scopeInput: e }, r.set(e, s)), s;
+}
+const tt = class tt {
+  /**
+   * 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(e, n) {
+    this.graph = e, 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(e) {
+    return Dr(this.graph.getDataManager(), e, this.input(_e(e)));
+  }
+  /**
+   * The graph this run computes over, in one orientation: its scope's compact snapshot when the
+   * class declares {@link Algorithm.scopeInput} and runs as a run, else the whole graph. Both
+   * seams below read through it.
+   * @param orientation - `"declared"` or `"undirected"`.
+   * @param options - How parallel edges merge; the class's {@link Algorithm.parallelEdges} by
+   *   default, else `"sum"`.
+   * @returns The input.
+   * @internal
+   */
+  input(e, n) {
+    const r = n?.simplify ?? this.constructor.parallelEdges, s = r === void 0 ? n : { ...n, simplify: r };
+    return sn(this.graph.getDataManager(), e, s, Rr(this));
+  }
+  /**
+   * One edge's record, by the id an input named it by: for an attribute the snapshot does not
+   * carry yet, such as a flow capacity. It is not a topology read -- the ids come from the input
+   * -- and it goes away once the store carries attribute columns.
+   * @param id - The edge's session id, from `scopeEdges`.
+   * @returns The record the edge was loaded from, or undefined.
+   * @internal
+   */
+  edgeRecord(e) {
+    return this.graph.getDataManager().getEdge(e)?.data;
+  }
+  /**
+   * The route an algorithm with an accelerated implementation takes.
+   *
+   * It is the counterpart of {@link algorithmGraph} for the algorithms `@graphty/algorithms`
+   * can dispatch: instead of copying the snapshot into an object graph, the work runs over the
+   * snapshot itself, on the attached accelerator or on the index-based CPU port, and the adapter
+   * writes one loop over an index-aligned result either way.
+   *
+   * THE DECISION IS TAKEN ONCE, HERE, BEFORE ANY WORK STARTS. The controller answers "the policy
+   * is off", "no accelerator", "below `acceleration.minNodes`" or "this accelerator does not
+   * implement that" up front, and under `acceleration="required"` it throws `E_NO_ACCELERATOR`
+   * rather than answering quietly. Two answers stay on the CPU even under `"required"`, because
+   * the device is not the element's to offer for them: a capability the element does not
+   * forward (betweenness and closeness today) never asks the controller, and a call the
+   * dispatcher itself keeps on the CPU port (an option or a graph shape the device's kernel is
+   * not defined for) runs there. Both say `f64`. 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.
+   * @param options - What the decision needs to know about this run.
+   * @param options.accelerable - False when the options of this run are ones no accelerator
+   *   answers, such as a walk that stops at a target, so the decision is the CPU port's (and
+   *   `E_NO_ACCELERATOR` under `acceleration="required"`). A capability the element does not
+   *   forward to an accelerator is never accelerable, whatever this says.
+   * @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(e, n, r) {
+    const { snapshot: s, edgeRemap: i } = this.input(_e(n)).derived(), o = this.graph.acceleration, a = {
+      capability: e,
+      nodeCount: s.nodeCount,
+      forwarded: (r?.accelerable ?? !0) && at(e)
+    };
+    return {
+      snapshot: s,
+      edgeRemap: i,
+      run: async (u) => {
+        if (at(e)) {
+          let c = !1;
+          const l = await o.run(
+            a,
+            (d) => u(
+              it(
+                Gn(d, () => {
+                  c = !0;
+                })
+              ),
+              s
+            )
+          );
+          if (l.accelerated) {
+            if (c)
+              return { value: l.value, precision: l.precision };
+            if (o.policy === "required")
+              throw new m({
+                code: "E_NO_ACCELERATOR",
+                message: `acceleration is required, but the accelerator does not answer this "${e}" run as asked, so it ran on the CPU`,
+                source: "acceleration",
+                details: { policy: "required", capability: e, nodeCount: s.nodeCount }
+              });
+            return { value: l.value, precision: ct };
+          }
+        }
+        return { value: await u(it(null), s), precision: ct };
+      }
+    };
+  }
+  /**
+   * 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(e, n, r) {
+    const s = e.ids.indexOf(r);
+    if (s === g)
+      throw new m({
+        code: "E_OPTION_RANGE",
+        message: `the graph has no node "${String(r)}", so "${n}" names nothing to run from`,
+        source: "run",
+        details: { option: n, value: r }
+      });
+    return s;
+  }
+  /**
+   * Resolves and validates options against the schema
+   * @param options - User-provided options (partial)
+   * @returns Fully resolved options with defaults applied
+   */
+  resolveOptions(e) {
+    const n = this.constructor.optionsSchema;
+    return Object.keys(n).length === 0 ? {} : Lr(n, e);
+  }
+  /**
+   * 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(e, n, r) {
+    return Promise.reject(
+      new m({
+        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
+   * @param options - Whether a different class under a key already taken throws instead of
+   *   replacing it.
+   * @returns The registered algorithm class
+   */
+  static register(e, n) {
+    const r = e, s = String(r.type), i = String(r.namespace), { descriptor: o, cost: a, costUnits: u, version: c } = r;
+    return o !== void 0 && nr(
+      {
+        descriptor: Ur(o, r.scopeInput ?? "none", `${i}:${s}`),
+        namespace: i,
+        type: s,
+        ...a === void 0 ? {} : { cost: a },
+        ...u === void 0 ? {} : { costUnits: u },
+        ...c === void 0 ? {} : { version: c }
+      },
+      n
+    ), Q.set(`${i}:${s}`, e), e;
+  }
+  /**
+   * 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(e, n, r, s) {
+    const i = Q.get(`${n}:${r}`);
+    return i ? new i(e, s) : null;
+  }
+  /**
+   * Gets an algorithm class from the registry
+   * @param namespace - The algorithm namespace
+   * @param type - The algorithm type
+   * @returns The algorithm class, or null if not found
+   */
+  static getClass(e, n) {
+    return Q.get(`${e}:${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(e) {
+    const n = [];
+    for (const r of Q.keys())
+      (!e || r.startsWith(`${e}:`)) && 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();
+  }
+};
+tt.optionsSchema = {};
+let Pe = tt;
+const At = 3, Hr = 0.1;
+function y(t, e) {
+  return Number.isInteger(t) ? t.toLocaleString(e) : Number(t.toFixed(At)).toLocaleString(e, { maximumFractionDigits: At });
+}
+function Br(t, e, n) {
+  const r = t.fields.find((s) => s.name === e);
+  return r === void 0 ? e : n === "technical" ? r.technicalName : r.plainName.toLowerCase();
+}
+function ve(t, e, n) {
+  const r = t.fields.find((s) => s.name === e)?.unit;
+  return r === void 0 ? "" : n === 1 && r.endsWith("s") ? ` ${r.slice(0, -1)}` : ` ${r}`;
+}
+function q(t, e) {
+  const n = t.graph[e];
+  return typeof n == "number" && Number.isFinite(n) ? n : void 0;
+}
+function Gr(t) {
+  return t[0];
+}
+function Vr(t, e, n) {
+  const { locale: r, audience: s } = n, i = Br(t, "value", s), o = Gr(e.top);
+  if (o === void 0 || e.median === null)
+    return `Nothing was measured, so there is no ${i} to report.`;
+  const a = [
+    `${o.label} has the highest ${i}, at ${y(o.value, r)}${ve(t, "value", o.value)}.`,
+    `The typical element sits at ${y(e.median, r)}${ve(t, "value", e.median)}.`
+  ];
+  return e.measured > 0 && e.tiedAtMin / e.measured >= Hr && e.min !== null && a.push(
+    `${y(e.tiedAtMin, r)} of ${y(e.measured, r)} sit at the lowest value, ${y(e.min, r)}${ve(t, "value", e.min)}.`
+  ), e.count > e.measured && a.push(`${y(e.count - e.measured, r)} were not measured.`), a.join(" ");
+}
+function Wr(t, e, n) {
+  const { locale: r } = n, s = e.groups ?? [];
+  if (s.length === 0)
+    return "Nothing was grouped, so there are no groups to report.";
+  const i = s[0], o = [
+    `${y(s.length, r)} ${s.length === 1 ? "group" : "groups"} were found,`,
+    `the largest holding ${y(i.size, r)} of ${y(e.measured, r)}.`
+  ], a = q(t, "modularity");
+  return a !== void 0 && o.push(`Modularity is ${y(a, r)}.`), o.join(" ");
+}
+function Yr(t, e) {
+  const { locale: n } = e, r = q(t, "hops"), s = q(t, "cost");
+  if (r === void 0 && s === void 0)
+    return "No route was found.";
+  const i = [];
+  return r !== void 0 && i.push(`The route runs ${y(r, n)} ${r === 1 ? "hop" : "hops"}.`), s !== void 0 && i.push(`Its total cost is ${y(s, n)}.`), i.join(" ");
+}
+function qr(t, e, n) {
+  const { locale: r } = n, s = q(t, "count") ?? e.measured, i = t.shape === "edge-set" ? "edge" : "node";
+  return s === 0 ? `No ${i}s were selected.` : `${y(s, r)} ${s === 1 ? i : `${i}s`} were selected.`;
+}
+function Jr(t, e) {
+  const { pairs: n } = t.graph, r = Array.isArray(n) ? n.length : 0;
+  return r === 0 ? "No pairs were found." : `${y(r, e.locale)} ${r === 1 ? "pair was" : "pairs were"} found.`;
+}
+function Kr(t, e) {
+  const n = q(t, "steps");
+  return n === void 0 || n === 0 ? "The series is empty." : `The series covers ${y(n, e.locale)} ${n === 1 ? "step" : "steps"}.`;
+}
+function kt(t, e) {
+  return t.measured === 0 ? "The run produced no values." : `The run covered ${y(t.measured, e.locale)} of ${y(t.count, e.locale)}.`;
+}
+function Zr(t, e) {
+  const n = t.summary(), { shape: r } = t;
+  switch (r) {
+    case "node-metric":
+    case "edge-metric":
+      return Vr(t, n, e);
+    case "community":
+    case "layered-grouping":
+    case "category-table":
+      return Wr(t, n, e);
+    case "path":
+      return Yr(t, e);
+    case "node-set":
+    case "edge-set":
+      return qr(t, n, e);
+    case "pair-list":
+      return Jr(t, e);
+    case "temporal":
+      return Kr(t, e);
+    case "fact":
+      return kt(n, e);
+    default:
+      return kt(n, e);
+  }
+}
+function Vi(t, e) {
+  const n = e === "node", r = n ? t.nodeValue : t.edgeValue, s = n ? t.nodeHas : t.edgeHas, i = n ? t.nodeIdOf : t.edgeIdOf;
+  return {
+    value: r,
+    has: s ?? ((o, a) => Xr(r(o, a))),
+    idOf: i ?? null
+  };
+}
+function Xr(t) {
+  return t != null;
+}
+function te(t) {
+  return t == null || t === !1 || t === "" ? !1 : Array.isArray(t) ? t.length > 0 : typeof t == "object" ? Object.keys(t).length > 0 : !0;
+}
+function xe(t, e) {
+  if (t === e)
+    return !0;
+  if (Array.isArray(t) && Array.isArray(e))
+    return t.length === e.length && t.every((n, r) => xe(n, e[r]));
+  if (St(t) && St(e)) {
+    const n = Object.keys(t);
+    return n.length === Object.keys(e).length && n.every((r) => xe(t[r], e[r]));
+  }
+  return !1;
+}
+function St(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t);
+}
+function w(t, e, n, r = {}) {
+  return new m({
+    code: "E_BAD_SELECTOR",
+    message: `${t} (at character ${String(n)} of ${JSON.stringify(e)})`,
+    source: "style",
+    details: { ...r, position: n, where: e }
+  });
+}
+const Qr = 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"
+}), es = ["&&", "||", "==", "!=", "<=", ">=", "!", "<", ">", ".", "(", ")"];
+function on(t) {
+  return /[A-Za-z_]/.test(t);
+}
+function an(t) {
+  return /[A-Za-z0-9_]/.test(t);
+}
+function Oe(t, e, n) {
+  for (let r = e + 1; r < t.length; r++) {
+    if (t[r] === "\\") {
+      r++;
+      continue;
+    }
+    if (t[r] === n)
+      return r;
+  }
+  throw w(`A ${n} is opened and never closed`, t, e, { delimiter: n });
+}
+function ts(t) {
+  let e = "";
+  for (let n = 0; n < t.length; n++) {
+    if (t[n] === "\\" && (t[n + 1] === "'" || t[n + 1] === "\\")) {
+      e += t[n + 1], n++;
+      continue;
+    }
+    e += t[n];
+  }
+  return e;
+}
+function ns(t, e, n) {
+  const r = n.replace(/\\`/g, "`");
+  try {
+    return JSON.parse(r);
+  } catch {
+    throw w(
+      `A literal between backticks must be JSON, so a bare word needs quotes: write \`"${r}"\` rather than \`${r}\``,
+      t,
+      e,
+      { literal: r }
+    );
+  }
+}
+function rs(t, e, n) {
+  try {
+    const r = JSON.parse(n);
+    if (typeof r == "string")
+      return r;
+  } catch {
+  }
+  throw w(`A quoted attribute name follows JSON's rules for a string, and ${n} does not`, t, e, {
+    name: n
+  });
+}
+function ss(t) {
+  const e = [];
+  let n = 0;
+  for (; n < t.length; ) {
+    const r = t.charAt(n);
+    if (/\s/.test(r)) {
+      n++;
+      continue;
+    }
+    const s = Qr[r];
+    if (s !== void 0)
+      throw w(`A selector does not support ${s}`, t, n, { construct: s });
+    if (r === "|" && t.charAt(n + 1) !== "|")
+      throw w("A selector does not support pipe expressions", t, n, {
+        construct: "pipe expressions"
+      });
+    if (r === "&" && t.charAt(n + 1) !== "&")
+      throw w("A selector does not support expression references", t, n, {
+        construct: "expression references"
+      });
+    const i = es.find((o) => t.startsWith(o, n));
+    if (i !== void 0) {
+      e.push({ kind: "operator", text: i, at: n }), n += i.length;
+      continue;
+    }
+    if (r === "`") {
+      const o = Oe(t, n, "`");
+      e.push({
+        kind: "literal",
+        text: "",
+        value: ns(t, n, t.slice(n + 1, o)),
+        at: n
+      }), n = o + 1;
+      continue;
+    }
+    if (r === "'") {
+      const o = Oe(t, n, "'");
+      e.push({ kind: "literal", text: "", value: ts(t.slice(n + 1, o)), at: n }), n = o + 1;
+      continue;
+    }
+    if (r === '"') {
+      const o = Oe(t, n, '"');
+      e.push({ kind: "identifier", text: rs(t, n, t.slice(n, o + 1)), at: n }), n = o + 1;
+      continue;
+    }
+    if (on(r)) {
+      let o = n + 1;
+      for (; o < t.length && an(t.charAt(o)); )
+        o++;
+      e.push({ kind: "identifier", text: t.slice(n, o), at: n }), n = o;
+      continue;
+    }
+    throw /[0-9-]/.test(r) ? w("A number in a selector goes between backticks, so write `5` rather than 5", t, n, {
+      character: r
+    }) : w(`${JSON.stringify(r)} is not something a selector can contain`, t, n, {
+      character: r
+    });
+  }
+  return e.push({ kind: "end", text: "", at: t.length }), e;
+}
+const is = Object.freeze({
+  "!=": "!=",
+  "<": "<",
+  "<=": "<=",
+  "==": "==",
+  ">": ">",
+  ">=": ">="
+});
+function x(t) {
+  return t.tokens[t.index];
+}
+function z(t, e) {
+  const n = x(t);
+  return n.kind === "operator" && n.text === e;
+}
+function os(t) {
+  const e = x(t), n = [];
+  for (; ; ) {
+    const r = x(t);
+    if (r.kind !== "identifier")
+      throw w("A `.` must be followed by an attribute name", t.where, r.at);
+    if (r.text.includes("."))
+      throw w(
+        `A quoted attribute name may not contain a dot: ${JSON.stringify(r.text)} would be indistinguishable from two names`,
+        t.where,
+        r.at,
+        { segment: r.text }
+      );
+    if (t.index++, z(t, "("))
+      throw w(
+        `A selector does not support functions, so ${r.text}(...) cannot be called here`,
+        t.where,
+        r.at,
+        { construct: "functions", function: r.text }
+      );
+    if (n.push(r.text), !z(t, "."))
+      return { kind: "path", path: n.join("."), at: e.at };
+    t.index++;
+  }
+}
+function as(t) {
+  const e = x(t);
+  if (e.kind === "literal")
+    return t.index++, { kind: "literal", value: e.value };
+  if (e.kind === "identifier")
+    return os(t);
+  if (z(t, "(")) {
+    t.index++;
+    const n = cn(t);
+    if (!z(t, ")"))
+      throw w("A `(` is opened and never closed", t.where, e.at);
+    return t.index++, { kind: "group", inner: n };
+  }
+  throw w(
+    e.kind === "end" ? "The selector ends where an attribute name, a literal or a `(` should be" : `${JSON.stringify(e.text)} is where an attribute name, a literal or a \`(\` should be`,
+    t.where,
+    e.at
+  );
+}
+function ze(t) {
+  if (!z(t, "!"))
+    return as(t);
+  const e = x(t);
+  t.index++;
+  const n = ze(t);
+  if (n.kind === "path" && n.path.includes("."))
+    throw w(
+      `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`,
+      t.where,
+      e.at,
+      { path: n.path }
+    );
+  return { kind: "not", operand: n };
+}
+function Et(t) {
+  const e = ze(t), n = x(t), r = n.kind === "operator" ? is[n.text] : void 0;
+  return r === void 0 ? e : (t.index++, { kind: "compare", operator: r, left: e, right: ze(t) });
+}
+function It(t) {
+  let e = Et(t);
+  for (; z(t, "&&"); )
+    t.index++, e = { kind: "and", left: e, right: Et(t) };
+  return e;
+}
+function cn(t) {
+  let e = It(t);
+  for (; z(t, "||"); )
+    t.index++, e = { kind: "or", left: e, right: It(t) };
+  return e;
+}
+function cs(t) {
+  const e = { where: t, tokens: ss(t), index: 0 }, n = cn(e), r = x(e);
+  if (r.kind !== "end")
+    throw w(
+      `${JSON.stringify(r.text)} is left over at the end of the selector`,
+      t,
+      r.at
+    );
+  return n;
+}
+function Y(t, e) {
+  switch (t.kind) {
+    case "path":
+      e.includes(t.path) || e.push(t.path);
+      return;
+    case "group":
+      Y(t.inner, e);
+      return;
+    case "not":
+      Y(t.operand, e);
+      return;
+    case "and":
+    case "or":
+    case "compare":
+      Y(t.left, e), Y(t.right, e);
+      return;
+    default:
+      return;
+  }
+}
+function E(t, e) {
+  switch (t.kind) {
+    case "path": {
+      const { path: n } = t, { value: r } = e;
+      return (s) => {
+        const i = r(s, n);
+        return i === void 0 ? null : i;
+      };
+    }
+    case "literal": {
+      const { value: n } = t;
+      return () => n;
+    }
+    case "group":
+      return E(t.inner, e);
+    case "not": {
+      const n = E(t.operand, e);
+      return (r) => !te(n(r));
+    }
+    case "and": {
+      const n = E(t.left, e), r = E(t.right, e);
+      return (s) => {
+        const i = n(s);
+        return te(i) ? r(s) : i;
+      };
+    }
+    case "or": {
+      const n = E(t.left, e), r = E(t.right, e);
+      return (s) => {
+        const i = n(s);
+        return te(i) ? i : r(s);
+      };
+    }
+    default:
+      return ds(t.operator, t.left, t.right, e);
+  }
+}
+const us = Object.freeze({
+  "<": (t, e) => t < e,
+  "<=": (t, e) => t <= e,
+  ">": (t, e) => t > e,
+  ">=": (t, e) => t >= e
+});
+function ls(t, e) {
+  return t.kind === "literal" ? t : e.kind === "literal" ? e : null;
+}
+function ds(t, e, n, r) {
+  if (t === "==" || t === "!=") {
+    const a = t === "==", u = e.kind === "literal", c = ls(e, n), l = u ? n : e;
+    if (c !== null && c.value === null && l.kind === "path") {
+      const { path: f } = l, { has: N } = r;
+      return (p) => N(p, f) !== a;
+    }
+    const d = E(e, r), h = E(n, r);
+    if (c !== null && c.value !== null && typeof c.value != "object") {
+      const { value: f } = c, N = u ? h : d;
+      return (p) => N(p) === f === a;
+    }
+    return (f) => xe(d(f), h(f)) === a;
+  }
+  const s = E(e, r), i = E(n, r), o = us[t];
+  return (a) => {
+    const u = s(a), c = i(a);
+    return typeof u == "number" && typeof c == "number" ? o(u, c) : null;
+  };
+}
+function L(t, e) {
+  switch (t.kind) {
+    case "compare":
+    case "not": {
+      const n = E(t, e);
+      return (r) => n(r) === !0;
+    }
+    case "group":
+      return L(t.inner, e);
+    case "and": {
+      const n = L(t.left, e), r = L(t.right, e);
+      return (s) => n(s) && r(s);
+    }
+    case "or": {
+      const n = L(t.left, e), r = L(t.right, e);
+      return (s) => n(s) || r(s);
+    }
+    default: {
+      const n = E(t, e);
+      return (r) => te(n(r));
+    }
+  }
+}
+function hs(t) {
+  return t.split(".").map((e) => fs(e) ? e : JSON.stringify(e)).join(".");
+}
+function fs(t) {
+  if (t === "" || !on(t[0]))
+    return !1;
+  for (let e = 1; e < t.length; e++)
+    if (!an(t[e]))
+      return !1;
+  return !0;
+}
+function Wi(t, e) {
+  const { has: n } = t;
+  return (r) => n(r, e);
+}
+function Yi(t, e) {
+  const { idOf: n } = t;
+  if (n === null)
+    throw new m({
+      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) => e.has(n(r));
+}
+function qi(t, e, n) {
+  const { value: r } = t;
+  return (s) => {
+    const i = n();
+    if (i === void 0)
+      return !1;
+    const o = r(s, e);
+    return typeof o == "number" && Number.isFinite(o) && o >= i;
+  };
+}
+function Ji(t, e) {
+  return (n) => {
+    const r = t.bits(e);
+    return r !== null && C(r, n);
+  };
+}
+function Ki(t, e) {
+  const n = cs(t), r = [];
+  if (Y(n, r), r.length === 0) {
+    let s = n;
+    for (; s.kind === "group"; )
+      s = s.inner;
+    const i = s.kind === "literal" && typeof s.value == "string";
+    throw w(
+      i ? "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',
+      t,
+      0,
+      { constant: !0 }
+    );
+  }
+  return { paths: Object.freeze(r), test: L(n, e) };
+}
+const Le = "results", ps = "$";
+function ne(t, e) {
+  return e === void 0 ? `${Le}.${t}` : `${Le}.${t}.${e}`;
+}
+function gs(t) {
+  return `Group ${String(t)}`;
+}
+function un(t, e) {
+  const n = Number(t), r = Number(e);
+  return Number.isFinite(n) && Number.isFinite(r) && String(n) === String(t) && String(r) === String(e) ? n - r : String(t).localeCompare(String(e));
+}
+const ln = {
+  // -- 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"]
+  }
+}, Zi = Object.keys(ln), Xe = {
+  "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 De(t) {
+  return Xe[t];
+}
+function Xi(t) {
+  return Xe[t].layer === "highlight";
+}
+function Qi(t, e) {
+  const n = Xe[t], r = [], s = [
+    { names: n.nodeFields, kind: "node" },
+    { names: n.edgeFields, kind: "edge" },
+    { names: n.graphFields, kind: "graph" }
+  ];
+  for (const { names: i, kind: o } of s)
+    for (const a of i) {
+      const u = e.find((l) => l.name === a && l.kind === o);
+      if (u === void 0) {
+        r.push({
+          field: a,
+          kind: o,
+          reason: `shape "${t}" requires a ${o} field named "${a}"`
+        });
+        continue;
+      }
+      const c = ln[a].types;
+      c.includes(u.type) || r.push({
+        field: a,
+        kind: o,
+        reason: `${o} field "${a}" is typed "${u.type}", not ${c.map((l) => `"${l}"`).join(" or ")}`
+      });
+    }
+  return n.headlineScalar && !ms(n, e) && r.push({
+    field: null,
+    kind: "graph",
+    reason: `shape "${t}" requires one graph-level scalar of its own beside "count"`
+  }), r;
+}
+function ms(t, e) {
+  const n = [...t.graphFields, ...t.optionalGraphFields];
+  return e.some((r) => r.kind === "graph" && !n.includes(r.name));
+}
+const ys = 3;
+function ws(t, e) {
+  if (t === e)
+    return 0;
+  const n = new Uint32Array(e.length + 1), r = new Uint32Array(e.length + 1);
+  for (let s = 0; s <= e.length; s++)
+    n[s] = s;
+  for (let s = 1; s <= t.length; s++) {
+    r[0] = s;
+    for (let i = 1; i <= e.length; i++) {
+      const o = n[i - 1] + (t[s - 1] === e[i - 1] ? 0 : 1);
+      r[i] = Math.min(r[i - 1] + 1, n[i] + 1, o);
+    }
+    n.set(r);
+  }
+  return n[e.length];
+}
+function bs(t, e, n = ys) {
+  const r = t.toLowerCase(), s = e.map((i) => ({
+    candidate: i,
+    distance: ws(r, i.toLowerCase())
+  }));
+  return s.sort((i, o) => i.distance - o.distance || i.candidate.localeCompare(o.candidate)), Object.freeze(s.slice(0, Math.max(n, 0)).map((i) => i.candidate));
+}
+function je(t) {
+  return typeof t == "string" ? t : "runId" in t ? t.runId : t.id;
+}
+function vs(t) {
+  return typeof t == "string" ? void 0 : t.shape;
+}
+function Os(t, e) {
+  return t.fields.some((n) => n.name === e) || e in t.graph;
+}
+class Ns {
+  #e;
+  /**
+   * Build the API over a registry.
+   * @param registry - Where runs are looked up.
+   */
+  constructor(e) {
+    this.#e = e;
+  }
+  /**
+   * 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(e, n) {
+    const r = je(e);
+    if (n !== void 0)
+      return ne(r, n);
+    const s = vs(e) ?? this.#e.entry(r)?.shape, i = s === void 0 ? null : De(s).primaryField;
+    return i === null ? ne(r) : ne(r, i);
+  }
+  /**
+   * 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(e, n) {
+    return hs(n === void 0 ? this.path(e) : this.path(e, 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(e) {
+    return this.#e.entry(je(e))?.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(e, n) {
+    const r = this.get(e);
+    return r === void 0 ? !1 : n === void 0 || Os(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 e = [];
+    for (const n of this.#e.entries())
+      n.result !== void 0 && e.push(Object.freeze({ runId: n.id, label: n.label, fields: n.result.fields }));
+    return Object.freeze(e);
+  }
+}
+const dn = /* @__PURE__ */ new WeakMap();
+function eo(t, e) {
+  const n = dn.get(t)?.entry(je(e));
+  return n?.result === void 0 ? void 0 : n.execution;
+}
+function to(t) {
+  const e = new Ns(t);
+  return dn.set(e, t), e;
+}
+const As = 20, Ne = 100, ks = 100, Ss = Object.freeze([]), Es = Object.freeze(["max", "min-max", "none"]);
+function hn(t) {
+  return typeof t == "string" && Es.includes(t);
+}
+function no(t) {
+  return {
+    length: t.length,
+    get: (e) => t[e]
+  };
+}
+const Is = Object.freeze({
+  measured: 0,
+  min: Number.NaN,
+  max: Number.NaN,
+  mean: Number.NaN,
+  median: Number.NaN,
+  tiedAtMin: 0,
+  smallestPositive: null
+});
+function fn(t) {
+  const { length: e } = t, n = new Float64Array(e);
+  let r = 0;
+  for (let h = 0; h < e; h++) {
+    const f = t.get(h);
+    Number.isFinite(f) && (n[r] = f, r++);
+  }
+  if (r === 0)
+    return { length: e, ...Is };
+  let s = Number.POSITIVE_INFINITY, i = Number.NEGATIVE_INFINITY, o = Number.POSITIVE_INFINITY, a = 0, u = 0;
+  for (let h = 0; h < r; h++) {
+    const f = n[h];
+    f < s && (s = f), f > i && (i = f), f > 0 && f < o && (o = f);
+    const N = f - u, p = a + N;
+    u = p - a - N, a = p;
+  }
+  const c = n.slice(0, r).sort(), l = c[Math.floor((r - 1) / 2)];
+  let d = 0;
+  for (; d < r && c[d] === s; )
+    d++;
+  return {
+    length: e,
+    measured: r,
+    min: s,
+    max: i,
+    mean: a / r,
+    median: l,
+    tiedAtMin: d,
+    smallestPositive: Number.isFinite(o) ? o : null
+  };
+}
+function pn(t) {
+  const e = fn(t);
+  return { view: Object.freeze({
+    length: t.length,
+    get: (r) => t.get(r),
+    min: e.min,
+    max: e.max,
+    mean: e.mean,
+    median: e.median
+  }), statistics: e };
+}
+function ro(t) {
+  const e = (s) => t[s].value, n = (s) => t[s].id, r = gn(t.length, e, n);
+  return Ue(r, r.length, e, n);
+}
+function gn(t, e, n) {
+  const r = [];
+  for (let i = 0; i < t; i++)
+    Number.isFinite(e(i)) && r.push(i);
+  const s = [];
+  for (const i of r)
+    s[i] = String(n(i));
+  return r.sort((i, o) => {
+    const a = e(i), u = e(o);
+    if (a !== u)
+      return u - a;
+    const c = s[i], l = s[o];
+    return c === l ? 0 : c < l ? -1 : 1;
+  }), Uint32Array.from(r);
+}
+function Ue(t, e, n, r) {
+  const s = t.length, i = [];
+  let o = 0, a = Number.NaN;
+  for (let u = 0; u < Math.min(e, s); u++) {
+    const c = n(t[u]);
+    c !== a && (o = u + 1, a = c), i.push(
+      Object.freeze({ id: r(t[u]), value: c, rank: o, percentile: (s - o + 1) / s })
+    );
+  }
+  return Object.freeze(i);
+}
+function $s(t, e) {
+  let n = Math.min(e, t.length);
+  for (; n > 0 && n < t.length && t[n].rank === t[n - 1].rank; )
+    n--;
+  if (n === t.length || n === e)
+    return Object.freeze({ entries: t.slice(0, n), leftOut: null, reason: null });
+  const { value: r } = t[n];
+  let s = n;
+  for (; s < t.length && t[s].value === r; )
+    s++;
+  const i = s - n, o = `${String(i)} tie at ${String(r)}, and taking them would make ${String(n + i)}, more than the ${String(e)} asked for, so ${n === 0 ? "none are" : `only the top ${String(n)} are`} taken.`;
+  return Object.freeze({
+    entries: t.slice(0, n),
+    leftOut: Object.freeze({ value: r, count: i }),
+    reason: o
+  });
+}
+function Rs(t) {
+  const { smallestPositive: e } = t;
+  if (t.measured === 0 || !(t.max > 0) || e === null)
+    return !1;
+  const n = t.min > 0 ? t.min : e;
+  return Math.log10(t.max) > Math.log10(n);
+}
+function Ms(t) {
+  return t.measured === 0 || !(t.median > 0) || t.max / t.median <= ks ? "linear" : Rs(t) ? "log" : "linear";
+}
+function Cs(t, e, n, r) {
+  if (!(e > t))
+    return { binCount: 1, indexOf: () => 0, rangeOf: () => [t, e] };
+  if (r) {
+    const i = e - t + 1, o = Math.ceil(i / Math.min(i, n)), a = Math.ceil(i / o);
+    return {
+      binCount: a,
+      indexOf: (u) => Math.min(Math.floor((u - t) / o), a - 1),
+      rangeOf: (u) => {
+        const c = t + u * o;
+        return [c, Math.min(c + o - 1, e)];
+      }
+    };
+  }
+  const s = (e - t) / n;
+  return {
+    binCount: n,
+    indexOf: (i) => Math.min(Math.floor((i - t) / s), n - 1),
+    rangeOf: (i) => [
+      t + i * s,
+      i === n - 1 ? e : t + (i + 1) * s
+    ]
+  };
+}
+function _s(t, e, n, r, s) {
+  const i = t > 0 ? 0 : 1, o = i === 0 ? t : n;
+  if (!(e > 0) || o === null || !(o > 0))
+    return null;
+  const a = Math.log10(o), u = Math.log10(e);
+  if (!(u > a))
+    return null;
+  const c = r - i;
+  if (c < 1)
+    return null;
+  const l = (u - a) / c;
+  return {
+    binCount: r,
+    indexOf: (d) => {
+      if (!(d > 0))
+        return 0;
+      const h = Math.floor((Math.log10(d) - a) / l);
+      return i + Math.min(Math.max(h, 0), c - 1);
+    },
+    rangeOf: (d) => {
+      if (d < i)
+        return [t, 0];
+      const h = d - i, f = h === 0 ? o : 10 ** (a + h * l), N = h === c - 1 ? e : 10 ** (a + (h + 1) * l);
+      if (!s)
+        return [f, N];
+      const p = h === 0 ? o : Math.ceil(f);
+      return [p, h === c - 1 ? e : Math.max(p, Math.ceil(N) - 1)];
+    }
+  };
+}
+function Fs(t) {
+  if (t === void 0)
+    return As;
+  if (!Number.isInteger(t) || t < 1 || t > Ne)
+    throw new m({
+      code: "E_OPTION_RANGE",
+      source: "run",
+      message: `A histogram takes between 1 and ${Ne} bins; ${String(t)} was asked for.`,
+      details: { option: "bins", value: t, min: 1, max: Ne }
+    });
+  return t;
+}
+function Ts(t, e) {
+  const n = /* @__PURE__ */ new Map();
+  for (let r = 0; r < t.length; r++) {
+    const s = t.get(r);
+    if (!Number.isFinite(s))
+      continue;
+    const i = n.get(s);
+    if (i === void 0) {
+      if (n.size >= e)
+        return null;
+      n.set(s, 1);
+      continue;
+    }
+    n.set(s, i + 1);
+  }
+  return n;
+}
+function Ps(t, e) {
+  const n = Fs(e?.bins), r = e?.integerValued ?? !1, s = fn(t), i = Ms(s), o = Ts(t, n);
+  if (o !== null) {
+    if (o.size === 0)
+      return Object.freeze({
+        bins: Ss,
+        // 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 d = [...o.entries()].sort((h, f) => h[0] - f[0]).map(([h, f]) => Object.freeze({ from: h, to: h, count: f }));
+    return Object.freeze({
+      bins: Object.freeze(d),
+      // 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: i,
+      binning: "per-value"
+    });
+  }
+  const u = e?.scale === "log" || e?.scale === "auto" && i === "log" ? _s(s.min, s.max, s.smallestPositive, n, r) : null, c = u ?? Cs(s.min, s.max, n, r), l = new Array(c.binCount).fill(0);
+  for (let d = 0; d < t.length; d++) {
+    const h = t.get(d);
+    Number.isFinite(h) && (l[c.indexOf(h)] += 1);
+  }
+  return Object.freeze({
+    bins: Object.freeze(
+      l.map((d, h) => {
+        const [f, N] = c.rangeOf(h);
+        return Object.freeze({ from: f, to: N, count: d });
+      })
+    ),
+    // `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: i,
+    binning: "banded"
+  });
+}
+const xs = 10, zs = 10, be = /* @__PURE__ */ Symbol("missing");
+class mn {
+  constructor() {
+    this.ids = [], this.positions = /* @__PURE__ */ new Map();
+  }
+  get size() {
+    return this.ids.length;
+  }
+  idOf(e) {
+    return this.ids[e];
+  }
+  indexOf(e) {
+    return this.positions.get(e) ?? -1;
+  }
+}
+function Ls(t) {
+  return 64 * t.size;
+}
+function $t(t) {
+  const e = new mn(), n = [];
+  for (const s of t ?? []) {
+    let i = e.positions.get(s.id);
+    i === void 0 && (i = e.ids.length, e.positions.set(s.id, i), e.ids.push(s.id)), n.push(i);
+  }
+  const r = { index: e, token: null, length: e.ids.length, columns: /* @__PURE__ */ new Map() };
+  return (t ?? []).forEach((s, i) => {
+    for (const [o, a] of Object.entries(s.values))
+      yn(r, o)[n[i]] = a;
+  }), r;
+}
+function yn(t, e) {
+  let n = t.columns.get(e);
+  return n === void 0 && (n = new Array(t.length).fill(be), t.columns.set(e, n)), n;
+}
+function Rt(t) {
+  for (const [e, n] of t.columns)
+    Array.isArray(n) && n.every((r) => typeof r == "number") && t.columns.set(e, Float64Array.from(n));
+}
+function K(t, e, n) {
+  const r = t.columns.get(e)?.[n];
+  return r === be ? void 0 : r;
+}
+function Mt(t, e) {
+  const n = t.index.indexOf(e);
+  if (!(n >= 0 && n < t.length))
+    return;
+  const r = {};
+  for (const [s, i] of t.columns) {
+    const o = i[n];
+    o !== be && (r[s] = o);
+  }
+  return Object.freeze(r);
+}
+function Ct(t) {
+  let e = 0;
+  for (const n of t.columns.values())
+    e += n instanceof Float64Array ? n.byteLength : 8 * n.length;
+  return e;
+}
+function D(t, e) {
+  const n = t.columns.get(e);
+  return {
+    length: t.length,
+    get: (r) => bn(n?.[r])
+  };
+}
+function wn(t, e) {
+  const n = D(t, e);
+  return gn(
+    t.length,
+    (r) => n.get(r),
+    (r) => t.index.idOf(r)
+  );
+}
+function bn(t) {
+  return typeof t == "number" ? t : Number.NaN;
+}
+function Qe(t) {
+  return typeof t == "string" || typeof t == "number";
+}
+function Ae(t) {
+  return t.type === "number" || t.type === "integer";
+}
+function A(t, e, n) {
+  t[e] === void 0 && (t[e] = n);
+}
+function He(t, e, n, r) {
+  const s = yn(t, e);
+  (s[n] === be || s[n] === void 0) && (s[n] = r);
+}
+function vn(t, e) {
+  const n = /* @__PURE__ */ new Map();
+  for (let r = 0; r < t.length; r++) {
+    const s = K(t, e, r);
+    Qe(s) && n.set(s, (n.get(s) ?? 0) + 1);
+  }
+  return n;
+}
+function Ds(t) {
+  const e = [...t.entries()].map(([n, r]) => ({ group: n, size: r }));
+  return e.sort((n, r) => r.size - n.size || un(n.group, r.group)), Object.freeze(e.map((n) => Object.freeze(n)));
+}
+function On(t, e) {
+  const n = t.find((r) => r.name === e)?.normalization;
+  return hn(n) ? n : "none";
+}
+function Nn(t, e, n) {
+  const r = wn(t, e), s = r.length;
+  let i = 0, o = Number.NaN;
+  for (let a = 0; a < s; a++) {
+    const u = r[a], c = bn(K(t, e, u));
+    c !== o && (i = a + 1, o = c), He(t, "rank", u, i), n && He(t, "percentile", u, (s - i + 1) / s);
+  }
+}
+function _t(t, e, n) {
+  const { statistics: r } = pn(D(t, "value"));
+  Nn(t, "value", !0), r.measured > 0 && (A(e, "min", r.min), A(e, "max", r.max), A(e, "median", r.median), A(e, "mean", r.mean)), A(e, "measured", r.measured), A(e, "tiedAtMin", r.tiedAtMin), A(e, "normalization", On(n, "value"));
+}
+function Ft(t, e, n, r, s) {
+  const i = vn(t, n);
+  for (let o = 0; o < t.length; o++) {
+    const a = K(t, n, o);
+    Qe(a) && He(t, r, o, i.get(a));
+  }
+  A(e, s, i.size), A(e, "sizes", Ds(i));
+}
+function js(t, e) {
+  Nn(t, "score", !1);
+  const n = [...vn(t, "category").entries()].map(([r, s]) => ({
+    category: String(r),
+    count: s
+  }));
+  n.sort((r, s) => s.count - r.count || un(r.category, s.category)), A(e, "categories", Object.freeze(n.map((r) => Object.freeze(r))));
+}
+function ee(t, e) {
+  let n = 0;
+  for (let r = 0; r < t.length; r++)
+    K(t, e, r) === !0 && n++;
+  return n;
+}
+function Tt(t, e) {
+  let n = 0;
+  for (let r = 0; r < t.length; r++)
+    K(t, e, r) !== void 0 && n++;
+  return n;
+}
+function Us(t, e, n, r, s) {
+  switch (t) {
+    case "node-metric":
+      _t(e, r, s);
+      break;
+    case "edge-metric":
+      _t(n, r, s);
+      break;
+    case "community":
+      Ft(e, r, "group", "groupSize", "groupCount");
+      break;
+    case "layered-grouping":
+      Ft(e, r, "level", "levelSize", "levelCount");
+      break;
+    case "category-table":
+      js(e, r);
+      break;
+    case "path":
+      A(r, "length", ee(e, "onPath")), A(r, "hops", ee(n, "onPath"));
+      break;
+    case "node-set":
+      A(r, "count", ee(e, "in"));
+      break;
+    case "edge-set":
+      A(r, "count", ee(n, "in"));
+      break;
+  }
+}
+function Hs(t) {
+  switch (t) {
+    case "node-metric":
+    case "edge-metric":
+      return "value";
+    case "category-table":
+      return "score";
+    case "layered-grouping":
+      return "level";
+    default:
+      return null;
+  }
+}
+function Bs(t, e, n) {
+  if (!Array.isArray(t))
+    return;
+  const r = [];
+  for (const s of t) {
+    if (typeof s != "object" || s === null)
+      continue;
+    const i = s, o = i.group ?? i.category, a = i.size ?? i.count;
+    if (Qe(o) && typeof a == "number" && r.push(Object.freeze(n ? { group: o, size: a, name: gs(r.length + 1) } : { group: o, size: a })), r.length === e)
+      break;
+  }
+  return Object.freeze(r);
+}
+class et {
+  #e;
+  #t;
+  #r;
+  #n;
+  #s;
+  #c;
+  #u = /* @__PURE__ */ new Map();
+  /** Each ranked field's order, as positions: four bytes per ranked element. */
+  #i = /* @__PURE__ */ new Map();
+  #o = /* @__PURE__ */ new Map();
+  #l;
+  /**
+   * 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(e, n, r, s) {
+    this.runId = e.runId, this.shape = e.shape, this.fields = Object.freeze([...e.fields]), this.measured = Object.freeze({ nodes: e.measured.nodes, edges: e.measured.edges }), this.graph = s, this.#e = n, this.#t = r, this.#r = e.caveats, this.#n = e.durationMs, this.#s = e.labelOf ?? (() => {
+    }), this.#c = e.reading ?? Zr;
+  }
+  /**
+   * One node's fields.
+   * @param id - The node id.
+   * @returns The fields, or undefined when the run produced nothing for that node.
+   */
+  node(e) {
+    return Mt(this.#e, e);
+  }
+  /**
+   * One edge's fields.
+   * @param id - The edge id.
+   * @returns The fields, or undefined when the run produced nothing for that edge.
+   */
+  edge(e) {
+    return Mt(this.#t, e);
+  }
+  /**
+   * 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(e) {
+    return this.#f(e).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(e, n) {
+    n !== void 0 && this.#d(n, "limit");
+    const r = this.#a(e), s = this.#p(e, r), i = D(r, e);
+    return Ue(
+      s,
+      n ?? s.length,
+      (o) => i.get(o),
+      (o) => r.index.idOf(o)
+    );
+  }
+  /**
+   * 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(e, n) {
+    const r = `${String(n)}:${e}`, s = this.#o.get(r);
+    if (s !== void 0)
+      return s;
+    const i = this.#d(n, "n"), o = this.#a(e), a = this.#p(e, o), u = D(o, e);
+    let c = Math.min(i, a.length);
+    if (c < a.length) {
+      const d = u.get(a[c]);
+      for (; c < a.length && u.get(a[c]) === d; )
+        c++;
+    }
+    const l = $s(
+      Ue(
+        a,
+        c,
+        (d) => u.get(d),
+        (d) => o.index.idOf(d)
+      ),
+      i
+    );
+    return this.#o.set(r, l), l;
+  }
+  /**
+   * Refuse a count of entries that is not a whole number.
+   * @param limit - The count.
+   * @param option - What the caller called it, for the refusal.
+   * @returns The count.
+   * @throws A GraphtyError coded E_OPTION_RANGE when it is not a whole number of entries.
+   */
+  #d(e, n) {
+    if (!Number.isInteger(e) || e < 0)
+      throw new m({
+        code: "E_OPTION_RANGE",
+        source: "run",
+        message: `A ranking limit is a whole number of entries, not ${String(e)}.`,
+        details: { option: n, value: e, min: 0 },
+        target: { kind: "run", id: this.runId }
+      });
+    return e;
+  }
+  /**
+   * 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(e, n) {
+    const r = this.#h(e), s = r.kind === "edge" ? this.#t : this.#e;
+    return Ps(D(s, e), {
+      ...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.#l ??= this.#m(), this.#l;
+  }
+  /**
+   * What this result means, in one sentence of plain language.
+   * @param options - The locale and how technical to be.
+   * @returns The sentence.
+   */
+  reading(e) {
+    return this.#c(this, e ?? {});
+  }
+  /**
+   * 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.
+   */
+  #g(e) {
+    const n = this.fields.find((r) => r.name === e && r.kind !== "graph");
+    return n !== void 0 && Ae(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.
+   */
+  #h(e) {
+    const n = this.fields.filter((i) => i.name === e), r = n.find((i) => i.kind !== "graph"), s = this.fields.filter((i) => i.kind !== "graph" && Ae(i)).map((i) => i.name);
+    if (r === void 0)
+      throw n.length > 0 ? new m({
+        code: "E_BAD_COMMAND",
+        source: "run",
+        message: `"${e}" is a graph-level field of run "${this.runId}"; read it from result.graph.`,
+        details: { field: e, kind: "graph", available: s },
+        target: { kind: "run", id: this.runId }
+      }) : new m({
+        code: "E_UNKNOWN_ATTRIBUTE",
+        source: "run",
+        message: `Run "${this.runId}" published no field named "${e}".`,
+        details: { field: e, available: s, candidates: bs(e, s) },
+        target: { kind: "run", id: this.runId }
+      });
+    if (!Ae(r))
+      throw new m({
+        code: "E_BAD_COMMAND",
+        source: "run",
+        message: `"${e}" is typed "${r.type}", which is not a column of numbers.`,
+        details: { field: e, type: r.type, available: s },
+        target: { kind: "run", id: this.runId }
+      });
+    return r;
+  }
+  /**
+   * The half of the result a per-element field belongs to.
+   * @param field - The field name.
+   * @returns The nodes or the edges.
+   * @throws A GraphtyError naming what went wrong.
+   */
+  #a(e) {
+    return this.#h(e).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.
+   */
+  #f(e) {
+    const n = this.#u.get(e);
+    if (n !== void 0)
+      return n;
+    const r = pn(D(this.#a(e), e));
+    return this.#u.set(e, r), r;
+  }
+  /**
+   * One field's ranking order, computed on the first ask and kept.
+   * @param field - The field to rank on.
+   * @param table - The half it belongs to.
+   * @returns The ranked positions, best first.
+   */
+  #p(e, n) {
+    let r = this.#i.get(e);
+    return r === void 0 && (r = wn(n, e), this.#i.set(e, r)), r;
+  }
+  /**
+   * What this result retains, in bytes: its columns and every cache it has built. Its id
+   * indexes are not counted; see {@link retentionOf}.
+   * @returns Bytes.
+   */
+  get byteSize() {
+    let e = Ct(this.#e) + Ct(this.#t);
+    for (const n of this.#i.values())
+      e += n.byteLength;
+    for (const n of this.#o.values())
+      e += 64 * n.entries.length;
+    return e;
+  }
+  /**
+   * The id indexes this result reads through, for whoever charges for them.
+   * @returns One per half that holds elements.
+   */
+  indexes() {
+    return [this.#e, this.#t].filter((e) => e.length > 0).map((e) => ({ index: e.index, token: e.token, bytes: Ls(e.index) }));
+  }
+  /**
+   * Read the nodes through a snapshot's id index instead of this result's own, when the two hold
+   * the same ids in the same order.
+   * @param index - The snapshot's node id index.
+   * @param token - The graph token of that snapshot.
+   */
+  shareNodeIndex(e, n) {
+    const r = this.#e;
+    if (!(r.index instanceof mn) || e.size !== r.length)
+      return;
+    const { ids: s } = r.index;
+    for (let i = 0; i < s.length; i++)
+      if (e.idOf(i) !== s[i])
+        return;
+    r.index = e, r.token = n;
+  }
+  /**
+   * Build the bounded form of this result.
+   * @returns The summary.
+   */
+  #m() {
+    const e = Hs(this.shape), n = e === null || this.#g(e) === null ? null : e, r = n === null ? null : this.#f(n).statistics, s = r !== null && r.measured > 0 ? r : null, i = n === null ? [] : this.ranking(n, xs).map(
+      (c) => Object.freeze({
+        id: c.id,
+        label: this.#s(c.id) ?? String(c.id),
+        value: c.value,
+        rank: c.rank,
+        percentile: c.percentile
+      })
+    ), o = {
+      count: this.#y(),
+      measured: r === null ? this.#w() : r.measured,
+      min: s === null ? null : s.min,
+      max: s === null ? null : s.max,
+      median: s === null ? null : s.median,
+      mean: s === null ? null : s.mean,
+      tiedAtMin: r === null ? 0 : r.tiedAtMin,
+      normalization: this.#b(n),
+      top: Object.freeze(i),
+      caveats: this.#r,
+      durationMs: this.#n
+    }, a = this.graph.sizes ?? this.graph.categories, u = Bs(a, zs, 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 e = De(this.shape), n = e.nodeFields.length > 0 ? this.measured.nodes : 0, r = e.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.
+   */
+  #w() {
+    const e = De(this.shape), { primaryField: n } = e;
+    if (n === null)
+      return 0;
+    const r = e.nodeFields.includes(n) ? Tt(this.#e, n) : 0, s = e.edgeFields.includes(n) ? Tt(this.#t, n) : 0;
+    return r + s;
+  }
+  /**
+   * How this result's values were scaled.
+   * @param valueField - The field a summary describes, or null when the shape measures no
+   *   number.
+   * @returns The normalisation the run published, the one its field declares, or "none".
+   */
+  #b(e) {
+    const n = this.graph.normalization;
+    return hn(n) ? n : e === null ? "none" : On(this.fields, e);
+  }
+}
+function Gs(t) {
+  const e = $t(t.nodes), n = $t(t.edges), r = { ...t.graph };
+  return Us(t.shape, e, n, r, t.fields), Rt(e), Rt(n), new et(t, e, n, Object.freeze(r));
+}
+function so(t) {
+  return t instanceof et ? { bytes: t.byteSize, indexes: t.indexes() } : { bytes: 0, indexes: [] };
+}
+function io(t, e, n) {
+  t instanceof et && t.shareNodeIndex(e, n);
+}
+const Vs = "Computed on the whole graph; values kept for the scope only.";
+function An(t) {
+  const { graph: e, resolution: n } = t;
+  return n.nodeCount === e.nodeCount && n.edgeCount === e.edgeCount;
+}
+function Be(t, e, n) {
+  return e !== g && e < n && C(t, e);
+}
+function ke(t, e) {
+  return `${String(t)} ${e}${t === 1 ? "" : "s"}`;
+}
+function Ws(t, e) {
+  if (!t)
+    return Vs;
+  const { nodeCount: n, edgeCount: r } = e.resolution;
+  return e.reading === "induced" ? `Computed on the induced subgraph of ${ke(n, "node")}.` : `Computed on the subgraph of ${ke(n, "node")} and the ${ke(r, "edge")} in scope.`;
+}
+function Ys(t, e) {
+  const n = Mr(t);
+  if (n === null || An(n))
+    return e;
+  const { graph: r, resolution: s } = n, i = (a) => Be(s.nodes, r.ids.indexOf(a.id), r.nodeCount), o = (a) => Be(s.edges, mr(r, a.id), r.edgeCount);
+  return {
+    ...e,
+    ...e.nodes === void 0 ? {} : { nodes: e.nodes.filter(i) },
+    ...e.edges === void 0 ? {} : { edges: e.edges.filter(o) },
+    caveats: {
+      ...e.caveats,
+      notes: [...e.caveats.notes, Ws(Ze(t), n)]
+    }
+  };
+}
+function oo(t, e, n) {
+  if (n === null || An(n))
+    return;
+  const { graph: r, resolution: s } = n;
+  for (const i of t) {
+    if (i.type !== "node-id" && i.type !== "node-set")
+      continue;
+    const o = e[i.name], a = Array.isArray(o) ? o : [o];
+    for (const u of a) {
+      if (typeof u != "string" && typeof u != "number")
+        continue;
+      const c = r.ids.indexOf(u);
+      if (c !== g && !Be(s.nodes, c, r.nodeCount))
+        throw new m({
+          code: "E_OPTION_RANGE",
+          message: `"${i.name}" names node "${String(u)}", which is outside the run's scope`,
+          source: "run",
+          details: { option: i.name, value: u, reason: "outside-scope" }
+        });
+    }
+  }
+}
+function qs(t) {
+  const e = t.styles?.config.data.knownFields.nodeLabelPath ?? null;
+  if (e === null)
+    return;
+  const n = t.getDataManager();
+  return (r) => {
+    const s = n.getNode(r)?.data[e];
+    return typeof s == "string" || typeof s == "number" ? String(s) : void 0;
+  };
+}
+function ao(t) {
+  return { exact: !0, precision: "f64", notes: [], ...t };
+}
+const Js = 1024, Ks = 16;
+function Zs() {
+  return {
+    input: () => {
+      throw new Error("A detached run context reads no graph: call computeRun, which binds the input.");
+    },
+    signal: new AbortController().signal,
+    report: () => {
+    },
+    yieldNow: () => new Promise((t) => {
+      setTimeout(t, 0);
+    })
+  };
+}
+async function co(t, e, n, r) {
+  const s = n.length;
+  t.report({ phase: e, completed: 0, total: s });
+  let i = performance.now();
+  for (let o = 0; o < s; o++)
+    o > 0 && o % Js === 0 && (t.signal.throwIfAborted(), t.report({ phase: e, completed: o, total: s }), performance.now() - i >= Ks && (await t.yieldNow(), i = performance.now())), r(n[o], o);
+  t.signal.throwIfAborted(), t.report({ phase: e, completed: s, total: s });
+}
+function Xs(t, e, n) {
+  const r = n?.find((i) => i.name === t.name && i.kind === t.kind), s = {
+    name: t.name,
+    plainName: r?.plainName ?? t.name,
+    technicalName: r?.technicalName ?? t.name,
+    kind: t.kind,
+    type: t.type,
+    path: ne(e, t.name),
+    ...r?.unit === void 0 ? {} : { unit: r.unit }
+  };
+  return t.normalization === void 0 ? s : { ...s, normalization: t.normalization };
+}
+class uo extends Pe {
+  /** 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(e) {
+    const { descriptor: n } = this.constructor;
+    return n === void 0 ? super.resolveOptions(e) : _n(n.options, e ?? {}, {
+      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(Zs(), 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(e, n, r) {
+    return this.computeRun(e, n, r);
+  }
+  /**
+   * Compute this algorithm's result, publish it under a run id, and project the 1.x view of it.
+   *
+   * This is what the run executor calls. The catalogue's own field descriptors are passed in
+   * because the catalogue states what a reader sees a field called and cannot be imported here
+   * without a cycle -- it reads these classes to publish their options.
+   * @param context - What the element gave the run: a signal, a progress channel and a yield.
+   *   The graph the run computes over is bound here, as the context's `input`.
+   * @param runId - The id the result is published under, which is the `<runId>` in
+   *   `results.<runId>`.
+   * @param declared - The catalogue's descriptors for this algorithm's fields, when the caller
+   *   holds them.
+   * @returns The result, or undefined when there was nothing to compute.
+   * @throws Whatever the context's signal throws once the run has been cancelled, which is a
+   *   `DOMException` named `AbortError`.
+   */
+  async computeRun(e, n, r) {
+    const s = Date.now(), i = {
+      signal: e.signal,
+      report: (l) => {
+        e.report(l);
+      },
+      yieldNow: () => e.yieldNow(),
+      input: (l, d) => this.input(l, d)
+    }, o = await this.compute(i);
+    if (o === null)
+      return;
+    const a = this.input("declared"), u = qs(this.graph), c = Gs(
+      Ys(this, {
+        ...u === void 0 ? {} : { labelOf: u },
+        runId: n,
+        shape: o.shape,
+        fields: o.fields.map((l) => Xs(l, n, r)),
+        measured: { nodes: a.nodeCount, edges: a.edgeCount },
+        graph: o.graph,
+        nodes: o.nodes,
+        edges: o.edges,
+        caveats: o.caveats,
+        durationMs: Date.now() - s
+      })
+    );
+    return this.#e = c, c;
+  }
+}
+function lo(t, e = "number") {
+  return [
+    { name: "value", kind: t, type: e },
+    { name: "rank", kind: t, type: "integer" },
+    { name: "percentile", kind: t, 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 Pt = [
+  { 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 ho(t) {
+  return t ? [...Pt, { name: "modularity", kind: "graph", type: "number" }] : Pt;
+}
+const fo = [
+  { name: "level", kind: "node", type: "integer" },
+  { name: "levelSize", kind: "node", type: "integer" },
+  { name: "levelCount", kind: "graph", type: "integer" },
+  { name: "sizes", kind: "graph", type: "table" }
+], po = [
+  { 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 go(t, e) {
+  return [
+    { name: "in", kind: t, type: "boolean" },
+    { name: "count", kind: "graph", type: "integer" },
+    { ...e, kind: "graph" }
+  ];
+}
+const Qs = `${Le}.${ps}`;
+function v(t) {
+  return { ...t, path: `${Qs}.${t.name}` };
+}
+function kn(t, e) {
+  return [
+    v({
+      name: "value",
+      plainName: e.plainName,
+      technicalName: e.technicalName,
+      kind: t,
+      type: e.type ?? "number",
+      ...e.unit === void 0 ? {} : { unit: e.unit }
+    }),
+    v({ name: "rank", plainName: "Rank", technicalName: "rank", kind: t, type: "integer" }),
+    v({ name: "percentile", plainName: "Percentile", technicalName: "percentile", kind: t, type: "number" }),
+    v({ name: "min", plainName: "Lowest", technicalName: "min", kind: "graph", type: "number" }),
+    v({ name: "max", plainName: "Highest", technicalName: "max", kind: "graph", type: "number" }),
+    v({ name: "median", plainName: "Middle", technicalName: "median", kind: "graph", type: "number" }),
+    v({ name: "mean", plainName: "Average", technicalName: "mean", kind: "graph", type: "number" }),
+    v({
+      name: "measured",
+      plainName: "Measured",
+      technicalName: "measured",
+      kind: "graph",
+      type: "integer"
+    }),
+    v({
+      name: "normalization",
+      plainName: "Normalization",
+      technicalName: "normalization",
+      kind: "graph",
+      type: "string"
+    }),
+    v({
+      name: "tiedAtMin",
+      plainName: "Tied at the lowest value",
+      technicalName: "tiedAtMin",
+      kind: "graph",
+      type: "integer"
+    })
+  ];
+}
+function mo(t) {
+  return kn("node", t);
+}
+function yo(t) {
+  return kn("edge", t);
+}
+function wo(t) {
+  const { plainName: e } = t, n = [
+    v({ name: "group", plainName: e, technicalName: t.technicalName, kind: "node", type: "integer" }),
+    v({
+      name: "groupSize",
+      plainName: `${e} size`,
+      technicalName: "groupSize",
+      kind: "node",
+      type: "integer"
+    }),
+    v({
+      name: "groupCount",
+      plainName: `${e} count`,
+      technicalName: "groupCount",
+      kind: "graph",
+      type: "integer"
+    }),
+    v({
+      name: "sizes",
+      plainName: `${e} sizes`,
+      technicalName: "sizes",
+      kind: "graph",
+      type: "table"
+    })
+  ];
+  return t.modularity === !0 ? [
+    ...n,
+    v({
+      name: "modularity",
+      plainName: "Community strength",
+      technicalName: "modularity",
+      kind: "graph",
+      type: "number"
+    })
+  ] : n;
+}
+export {
+  ci as $,
+  Pe as A,
+  Le as B,
+  Xe as C,
+  gi as D,
+  Zr as E,
+  pi as F,
+  hs as G,
+  ne as H,
+  qt as I,
+  ar as J,
+  rr as K,
+  fo as L,
+  Gt as M,
+  pr as N,
+  k as O,
+  po as P,
+  gr as Q,
+  Zi as R,
+  Un as S,
+  H as T,
+  Ei as U,
+  di as V,
+  jn as W,
+  ct as X,
+  Ks as Y,
+  xn as Z,
+  hi as _,
+  uo as a,
+  Ai as a0,
+  Di as a1,
+  ji as a2,
+  qs as a3,
+  Gs as a4,
+  Ys as a5,
+  S as a6,
+  Lt as a7,
+  Gi as a8,
+  oo as a9,
+  wr as aA,
+  Or as aB,
+  Fi as aC,
+  nn as aD,
+  Li as aE,
+  zi as aF,
+  $s as aG,
+  ro as aH,
+  fn as aI,
+  no as aJ,
+  Pi as aK,
+  Ki as aL,
+  Vi as aM,
+  De as aN,
+  mr as aO,
+  un as aP,
+  bs as aQ,
+  Ji as aR,
+  qi as aS,
+  Yi as aT,
+  Wi as aU,
+  gs as aV,
+  Xi as aW,
+  to as aX,
+  io as aY,
+  eo as aZ,
+  Hi as aa,
+  Ti as ab,
+  zn as ac,
+  Ui as ad,
+  yi as ae,
+  mi as af,
+  bi as ag,
+  wi as ah,
+  Ie as ai,
+  Mi as aj,
+  Ke as ak,
+  en as al,
+  Me as am,
+  Ci as an,
+  _i as ao,
+  $i as ap,
+  Ri as aq,
+  xe as ar,
+  P as as,
+  b as at,
+  so as au,
+  zt as av,
+  Ce as aw,
+  X as ax,
+  yr as ay,
+  xi as az,
+  Se as b,
+  li as c,
+  Qi as d,
+  Ii as e,
+  ki as f,
+  ui as g,
+  ho as h,
+  wo as i,
+  ao as j,
+  Bi as k,
+  yo as l,
+  co as m,
+  v as n,
+  lo as o,
+  mo as p,
+  vi as q,
+  Oi as r,
+  Si as s,
+  Ni as t,
+  ai as u,
+  Lr as v,
+  go as w,
+  xr as x,
+  Vn as y,
+  fi as z
+};