@graphty/graphty-element 2.3.0 → 2.3.1

package/dist/chunks/algorithms-CpX56sUB.js

@@ -0,0 +1,3482 @@
+import { c as it } from "./common-DWNKjpH_.js";
+import { N as st, E as Je } from "./NodeStyle-DKj7HjMJ.js";
+import { F as ot, k as rt, a as z, h as N, P as Qe, f as M, A as S, Y as ct, G as lt, H as dt, n as $, L as qe, s as We, e as _, m as oe, i as je, o as Ue } from "./optionsFromZod-17lkrAJs.js";
+import { z as c } from "zod/v4";
+import { bellmanFord as ht, betweennessCentrality as ut, breadthFirstSearch as pt, bipartitePartition as mt, maximumBipartiteMatching as gt, closenessCentrality as ft, depthFirstSearch as yt, eigenvectorCentrality as bt, ConvergenceError as wt, floydWarshall as vt, girvanNewman as Nt, hits as kt, katzCentrality as St, labelPropagation as Ot, leiden as xt, louvain as It, Graph as _e, fordFulkerson as Mt, kargerMinCut as Ct, stoerWagner as zt, minSTCut as Tt, pageRank as Et, primMST as Dt, stronglyConnectedComponents as Pt } from "@graphty/algorithms";
+import { G as et } from "./GraphtyError-BwcnblTH.js";
+import { INVALID_INDEX as R } from "@graphty/graph-format";
+var Oa = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function xa(s) {
+  return s && s.__esModule && Object.prototype.hasOwnProperty.call(s, "default") ? s.default : s;
+}
+const Rt = /^#?(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i;
+function Le(s) {
+  return Number.isFinite(s) ? Math.max(0, Math.min(255, Math.round(s))) : 0;
+}
+function ne(s) {
+  return s.toString(16).padStart(2, "0");
+}
+function Ft(s) {
+  if (!Rt.test(s))
+    return null;
+  const e = s.startsWith("#") ? s.slice(1) : s, t = e.length <= 4, n = (i) => {
+    const o = t ? e[i].repeat(2) : e.slice(i * 2, i * 2 + 2);
+    return parseInt(o, 16);
+  }, a = e.length === 4 || e.length === 8;
+  return {
+    r: n(0),
+    g: n(1),
+    b: n(2),
+    a: a ? n(3) / 255 : 1
+  };
+}
+function Ia(s) {
+  return typeof s != "object" || s === null || !("hex" in s) ? null : s;
+}
+function $t(s) {
+  if (s == null)
+    return null;
+  if (typeof s == "object")
+    return Ae(s);
+  const e = Ft(s);
+  if (e !== null)
+    return Ae(e);
+  try {
+    const t = it(s);
+    return t === void 0 ? null : $t(t);
+  } catch {
+    return null;
+  }
+}
+function Ae(s) {
+  const e = Le(s.r), t = Le(s.g), n = Le(s.b), a = Number.isFinite(s.a) ? Math.max(0, Math.min(1, s.a)) : 1, i = `#${ne(e)}${ne(t)}${ne(n)}`;
+  return { r: e, g: t, b: n, a, hex: a === 1 ? i : `${i}${ne(Math.round(a * 255))}` };
+}
+const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options, Be = Je.shape.arrowHead.unwrap().shape.type.unwrap().unwrap().options, Wt = "An outline has a colour and no width. Babylon draws it with a highlight LAYER, and the stroke's blur size belongs to that layer rather than to a mesh, so every outline on screen is drawn at one width whatever a style asks for -- which is why the node style declares no outline width to ask with. The outline's COLOUR is per style; a width per style would need one highlight layer per width, at a full-screen pass each.", ie = 'A caption hangs from the cap at that end of the edge, so an end drawn with no arrow carries none: a tail caption needs `edge.arrowTail` set to something other than "none". The words are what switch a caption on, so a layer that writes only the caption\'s appearance and no words draws nothing, exactly as `node.labelStyle` draws nothing without `node.label`.', Ye = "A tooltip is drawn on hover and only on hover, so a graph at rest shows none: a layer that writes one changes nothing until a reader points at the node. The words are what switch it on, so a layer that writes only the tooltip's appearance and no words draws nothing, exactly as `node.labelStyle` draws nothing without `node.label`. Only a NODE has a tooltip; `edge.tooltip` was withdrawn in 2.0 because an edge cannot be hovered.", te = {
+  "node.color": {
+    channel: "node.color",
+    target: "node",
+    plainName: "Node Colour",
+    accepts: "color",
+    stylePath: "texture.color",
+    renderable: !0
+  },
+  "node.size": {
+    channel: "node.size",
+    target: "node",
+    plainName: "Node Size",
+    accepts: "number",
+    min: 0,
+    stylePath: "shape.size",
+    renderable: !0
+  },
+  "node.shape": {
+    channel: "node.shape",
+    target: "node",
+    plainName: "Node Shape",
+    accepts: "enum",
+    values: Gt,
+    stylePath: "shape.type",
+    renderable: !0
+  },
+  "node.label": {
+    channel: "node.label",
+    target: "node",
+    plainName: "Node Label",
+    accepts: "text",
+    stylePath: "label.text",
+    renderable: !0
+  },
+  "node.labelStyle": {
+    channel: "node.labelStyle",
+    target: "node",
+    plainName: "Node Label Style",
+    accepts: "labelStyle",
+    stylePath: "label",
+    renderable: !0
+  },
+  "node.tooltip": {
+    channel: "node.tooltip",
+    target: "node",
+    plainName: "Node Tooltip",
+    accepts: "text",
+    stylePath: "tooltip.text",
+    renderable: !0,
+    caveat: Ye
+  },
+  "node.tooltipStyle": {
+    channel: "node.tooltipStyle",
+    target: "node",
+    plainName: "Node Tooltip Style",
+    accepts: "labelStyle",
+    stylePath: "tooltip",
+    renderable: !0,
+    caveat: Ye
+  },
+  "node.opacity": {
+    channel: "node.opacity",
+    target: "node",
+    plainName: "Node Opacity",
+    accepts: "number",
+    min: 0,
+    max: 1,
+    stylePath: "texture.color.opacity",
+    renderable: !0
+  },
+  "node.outline": {
+    channel: "node.outline",
+    target: "node",
+    plainName: "Node Outline",
+    accepts: "color",
+    stylePath: "effect.outline.color",
+    renderable: !0,
+    caveat: Wt
+  },
+  "node.glow": {
+    channel: "node.glow",
+    target: "node",
+    plainName: "Node Glow",
+    accepts: "color",
+    stylePath: "effect.glow.color",
+    renderable: !0
+  },
+  "node.glowStrength": {
+    channel: "node.glowStrength",
+    target: "node",
+    plainName: "Node Glow Strength",
+    accepts: "number",
+    min: 0,
+    stylePath: "effect.glow.strength",
+    renderable: !0
+  },
+  "node.wireframe": {
+    channel: "node.wireframe",
+    target: "node",
+    plainName: "Node Wireframe",
+    accepts: "boolean",
+    stylePath: "effect.wireframe",
+    renderable: !0
+  },
+  "node.flat": {
+    channel: "node.flat",
+    target: "node",
+    plainName: "Node Flat Shading",
+    accepts: "boolean",
+    stylePath: "effect.flatShaded",
+    renderable: !0
+  },
+  "node.marker": {
+    channel: "node.marker",
+    target: "node",
+    plainName: "Node Marker",
+    accepts: "nothing",
+    stylePath: "texture.icon",
+    renderable: !1,
+    caveat: "The element draws no marker. texture.icon is in the node schema and no renderer reads it, and the badge vocabulary belongs to a label rather than to a node."
+  },
+  "edge.color": {
+    channel: "edge.color",
+    target: "edge",
+    plainName: "Edge Colour",
+    accepts: "color",
+    stylePath: "line.color",
+    renderable: !0
+  },
+  "edge.width": {
+    channel: "edge.width",
+    target: "edge",
+    plainName: "Edge Width",
+    accepts: "number",
+    min: 0,
+    stylePath: "line.width",
+    renderable: !0
+  },
+  "edge.opacity": {
+    channel: "edge.opacity",
+    target: "edge",
+    plainName: "Edge Opacity",
+    accepts: "number",
+    min: 0,
+    max: 1,
+    stylePath: "line.opacity",
+    renderable: !0
+  },
+  "edge.style": {
+    channel: "edge.style",
+    target: "edge",
+    plainName: "Edge Line Pattern",
+    accepts: "enum",
+    values: Ht,
+    stylePath: "line.type",
+    renderable: !0
+  },
+  "edge.patternCount": {
+    channel: "edge.patternCount",
+    target: "edge",
+    plainName: "Edge Pattern Count",
+    accepts: "number",
+    min: 2,
+    stylePath: "line.patternCount",
+    renderable: !0,
+    caveat: "A cap on how many dots or dashes a patterned edge draws, and it applies to a patterned line only: a solid line has no elements to count, and zigzag and sinewave always tile the whole edge, so they ignore it. Left unset, the spacing rule decides, so a long edge or a thin one draws more of them."
+  },
+  "edge.curvature": {
+    channel: "edge.curvature",
+    target: "edge",
+    plainName: "Edge Curve",
+    accepts: "boolean",
+    stylePath: "line.bezier",
+    renderable: !0,
+    caveat: "A switch, not an amount: the renderer offsets its control points by a fixed fraction of the edge's length, so how far an edge bows cannot be set."
+  },
+  "edge.arrowHead": {
+    channel: "edge.arrowHead",
+    target: "edge",
+    plainName: "Arrow Head",
+    accepts: "enum",
+    values: Be,
+    stylePath: "arrowHead.type",
+    renderable: !0
+  },
+  "edge.arrowHeadSize": {
+    channel: "edge.arrowHeadSize",
+    target: "edge",
+    plainName: "Arrow Head Size",
+    accepts: "number",
+    min: 0,
+    stylePath: "arrowHead.size",
+    renderable: !0
+  },
+  "edge.arrowHeadColor": {
+    channel: "edge.arrowHeadColor",
+    target: "edge",
+    plainName: "Arrow Head Colour",
+    accepts: "color",
+    stylePath: "arrowHead.color",
+    renderable: !0
+  },
+  "edge.arrowHeadOpacity": {
+    channel: "edge.arrowHeadOpacity",
+    target: "edge",
+    plainName: "Arrow Head Opacity",
+    accepts: "number",
+    min: 0,
+    max: 1,
+    stylePath: "arrowHead.opacity",
+    renderable: !0
+  },
+  "edge.arrowHeadText": {
+    channel: "edge.arrowHeadText",
+    target: "edge",
+    plainName: "Arrow Head Caption",
+    accepts: "text",
+    stylePath: "arrowHead.text.text",
+    renderable: !0,
+    caveat: ie
+  },
+  "edge.arrowHeadTextStyle": {
+    channel: "edge.arrowHeadTextStyle",
+    target: "edge",
+    plainName: "Arrow Head Caption Style",
+    accepts: "labelStyle",
+    stylePath: "arrowHead.text",
+    renderable: !0,
+    caveat: ie
+  },
+  "edge.arrowTail": {
+    channel: "edge.arrowTail",
+    target: "edge",
+    plainName: "Arrow Tail",
+    accepts: "enum",
+    values: Be,
+    stylePath: "arrowTail.type",
+    renderable: !0
+  },
+  "edge.arrowTailSize": {
+    channel: "edge.arrowTailSize",
+    target: "edge",
+    plainName: "Arrow Tail Size",
+    accepts: "number",
+    min: 0,
+    stylePath: "arrowTail.size",
+    renderable: !0
+  },
+  "edge.arrowTailColor": {
+    channel: "edge.arrowTailColor",
+    target: "edge",
+    plainName: "Arrow Tail Colour",
+    accepts: "color",
+    stylePath: "arrowTail.color",
+    renderable: !0
+  },
+  "edge.arrowTailOpacity": {
+    channel: "edge.arrowTailOpacity",
+    target: "edge",
+    plainName: "Arrow Tail Opacity",
+    accepts: "number",
+    min: 0,
+    max: 1,
+    stylePath: "arrowTail.opacity",
+    renderable: !0
+  },
+  "edge.arrowTailText": {
+    channel: "edge.arrowTailText",
+    target: "edge",
+    plainName: "Arrow Tail Caption",
+    accepts: "text",
+    stylePath: "arrowTail.text.text",
+    renderable: !0,
+    caveat: ie
+  },
+  "edge.arrowTailTextStyle": {
+    channel: "edge.arrowTailTextStyle",
+    target: "edge",
+    plainName: "Arrow Tail Caption Style",
+    accepts: "labelStyle",
+    stylePath: "arrowTail.text",
+    renderable: !0,
+    caveat: ie
+  },
+  "edge.animationSpeed": {
+    channel: "edge.animationSpeed",
+    target: "edge",
+    plainName: "Edge Animation Speed",
+    accepts: "number",
+    min: 0,
+    stylePath: "line.animationSpeed",
+    renderable: !0
+  },
+  "edge.label": {
+    channel: "edge.label",
+    target: "edge",
+    plainName: "Edge Label",
+    accepts: "text",
+    stylePath: "label.text",
+    renderable: !0
+  },
+  "edge.labelStyle": {
+    channel: "edge.labelStyle",
+    target: "edge",
+    plainName: "Edge Label Style",
+    accepts: "labelStyle",
+    stylePath: "label",
+    renderable: !0
+  }
+}, tt = Object.keys(te);
+tt.filter(
+  (s) => te[s].accepts === "color"
+);
+function Kt(s) {
+  return typeof s == "string" && Object.hasOwn(te, s);
+}
+function Ma(s) {
+  return Kt(s) ? te[s] : void 0;
+}
+function Ca(s) {
+  return tt.map((e) => te[e]).filter(
+    (e) => e.target === s
+  );
+}
+const at = Object.freeze([
+  {
+    id: "fitToGraph",
+    plainName: "Fit to graph",
+    description: "Frames every element, from an angle in 3D and straight on in 2D.",
+    modes: ["2d", "3d"],
+    options: []
+  },
+  {
+    id: "topView",
+    plainName: "From above",
+    description: "Looks straight down at the graph. The natural view for a flat arrangement.",
+    modes: ["2d", "3d"],
+    options: []
+  },
+  {
+    id: "sideView",
+    plainName: "From the side",
+    description: "Looks along the x axis, which shows how deep an arrangement is.",
+    modes: ["3d"],
+    options: []
+  },
+  {
+    id: "frontView",
+    plainName: "From the front",
+    description: "Looks along the z axis, straight at the face of the arrangement.",
+    modes: ["3d"],
+    options: []
+  },
+  {
+    id: "isometric",
+    plainName: "Isometric",
+    description: "The classic three-quarter view: 45 degrees around and about 35 degrees up.",
+    modes: ["3d"],
+    options: []
+  }
+]);
+function za(s) {
+  return at.find((e) => e.id === s) ?? ot(s)?.descriptor;
+}
+function Ta(s) {
+  return [...at, ...rt()].filter(
+    (e) => e.modes.includes(s)
+  );
+}
+function Ea(s) {
+  return s;
+}
+function Lt(s) {
+  const e = {};
+  for (const [t, n] of Object.entries(s))
+    e[t] = n.schema;
+  return c.object(e);
+}
+function Ut(s, e) {
+  return Lt(s).parse(e);
+}
+function T(s, e) {
+  return `${String(s)}:${String(e)}`;
+}
+function re(s, e, t, n) {
+  const a = String(t);
+  if (!n.some((i) => String(i) === a))
+    throw new et({
+      code: "E_OPTION_RANGE",
+      source: "run",
+      message: `${s}: the ${e} option names node "${a}", which is not in the graph.`,
+      details: { algorithm: s, option: e, value: t }
+    });
+  return a;
+}
+const jt = {
+  source: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Source Node",
+      description: "Starting node for shortest path (uses first node if not set)"
+    }
+  },
+  target: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Target Node",
+      description: "Destination node for shortest path (uses last node if not set)"
+    }
+  }
+}, W = class W extends z {
+  constructor() {
+    super(...arguments), this.legacyOptions = null;
+  }
+  /**
+   * Configure the algorithm with source and optional target nodes
+   * @param options - Configuration options
+   * @param options.source - The source node ID
+   * @param options.target - The optional target node ID
+   * @returns This algorithm instance for chaining
+   * @deprecated Use constructor options instead. This method is kept for backward compatibility.
+   */
+  configure(e) {
+    return this.legacyOptions = e, this;
+  }
+  /**
+   * Find the cheapest route from the source to the target, negative weights included.
+   *
+   * Publishes the same path fields Dijkstra does, because the engine is a parameter of the
+   * question and not a different question. What is different is what the method can tell you:
+   * it detects a loop that costs less every time round, and it says so on the graph half of
+   * the result, where a distance computed in the presence of one cannot be trusted.
+   * @param context - What the element gave the run.
+   * @returns The route, or null when there are no nodes to search.
+   */
+  async compute(e) {
+    const t = this.graph.getDataManager(), n = Array.from(t.nodes.keys());
+    if (n.length === 0)
+      return null;
+    const a = this.legacyOptions?.source ?? this._schemaOptions.source ?? n[0], i = this.legacyOptions?.target ?? this._schemaOptions.target ?? n[n.length - 1], o = this.algorithmGraph("undirected");
+    e.report({ phase: "Relaxing edges", total: null });
+    const r = ht(o, a), d = this.reconstructPath(r.predecessors, a, i), h = /* @__PURE__ */ new Map();
+    d.forEach((f, O) => h.set(f, O));
+    for (const f of r.distances.values())
+      ;
+    const m = [];
+    await N(e, "Marking the route", n, (f) => {
+      const O = h.get(f), y = r.distances.get(f) ?? 1 / 0;
+      m.push({ id: f, values: { onPath: O !== void 0, order: O, distance: y } });
+    });
+    const l = this.getPathEdges(d), u = [];
+    await N(e, "Marking the route", Array.from(t.edges.values()), (f) => {
+      const O = T(f.srcId, f.dstId), y = T(f.dstId, f.srcId);
+      u.push({ id: f.id, values: { onPath: l.has(O) || l.has(y) } });
+    });
+    const p = [`Route from ${String(a)} to ${String(i)}.`];
+    return r.hasNegativeCycle && p.push("A loop that costs less every time round was found, so no distance past it is meaningful."), {
+      shape: "path",
+      fields: [
+        ...Qe,
+        { name: "distance", kind: "node", type: "number" },
+        { name: "hasNegativeCycle", kind: "graph", type: "boolean" }
+      ],
+      nodes: m,
+      edges: u,
+      graph: {
+        length: d.length,
+        cost: d.length > 0 ? r.distances.get(i) ?? 0 : 0,
+        hops: Math.max(d.length - 1, 0),
+        hasNegativeCycle: r.hasNegativeCycle
+      },
+      caveats: M({
+        method: "bellman-ford",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "distance" },
+        notes: p
+      })
+    };
+  }
+  /**
+   * Reconstruct the shortest path from predecessors
+   * @param predecessors - Map of node to its predecessor in the shortest path
+   * @param source - The source node
+   * @param target - The target node
+   * @returns Array of node IDs representing the shortest path
+   */
+  reconstructPath(e, t, n) {
+    const a = [];
+    let i = n;
+    for (; i !== null && (a.unshift(i), i !== t); )
+      i = e.get(i) ?? null;
+    return a.length === 0 || a[0] !== t ? [] : a;
+  }
+  /**
+   * Get set of edge keys that are part of the path
+   * @param path - Array of node IDs representing the path
+   * @returns Set of edge keys in "srcId:dstId" format
+   */
+  getPathEdges(e) {
+    const t = /* @__PURE__ */ new Set();
+    for (let n = 0; n < e.length - 1; n++)
+      t.add(T(e[n], e[n + 1]));
+    return t;
+  }
+};
+W.namespace = "graphty", W.type = "bellman-ford", W.zodOptionsSchema = jt, W.optionsSchema = {
+  source: {
+    type: "nodeId",
+    default: null,
+    label: "Source Node",
+    description: "Starting node for shortest path (uses first node if not set)",
+    required: !1
+  },
+  target: {
+    type: "nodeId",
+    default: null,
+    label: "Target Node",
+    description: "Destination node for shortest path (uses last node if not set)",
+    required: !1
+  }
+};
+let ce = W;
+S.register(ce);
+const Vt = 2048;
+function qt(s) {
+  return {
+    runId: s,
+    signal: new AbortController().signal,
+    report: () => {
+    },
+    yieldNow: () => new Promise((e) => {
+      setTimeout(e, 0);
+    })
+  };
+}
+async function F(s, e, t, n) {
+  const a = s.length;
+  let i = performance.now();
+  for (let o = 0; o < a; o++)
+    e.signal.throwIfAborted(), n(s[o], o), (o + 1) % Vt === 0 && o + 1 < a && (e.report({ phase: t, completed: o + 1, total: a }), performance.now() - i >= ct && (await e.yieldNow(), i = performance.now()));
+  e.report({ phase: t, completed: a, total: a });
+}
+class G extends S {
+  /** What the last run published, kept so a caller that has the algorithm can read the result. */
+  #e;
+  /**
+   * What the last run published.
+   * @returns The result, or undefined when nothing has run or the graph was empty.
+   */
+  get result() {
+    return this.#e;
+  }
+  /**
+   * Run the algorithm.
+   *
+   * This is the 1.10 entry point and it still returns nothing, because `AlgorithmManager` and
+   * every caller behind `element.runAlgorithm` still expect that. It publishes a result all the
+   * same: read {@link MetricAlgorithm.result}, or call {@link MetricAlgorithm.measureRun} with a
+   * run context to get one back.
+   * @returns A promise that settles once the result has been published.
+   */
+  async run() {
+    await this.measureRun(qt(this.type));
+  }
+  /**
+   * Measure the graph on behalf of a run, and hand the result back.
+   *
+   * The run machinery's entry point. A metric's own context is its run context plus the run id,
+   * so this is the whole of the translation.
+   * @param context - A signal, a progress channel and a yield.
+   * @param runId - The id the result is published under.
+   * @returns The result, or undefined when there was nothing to measure.
+   * @throws Whatever the context's signal throws once the run has been cancelled.
+   */
+  publishResult(e, t) {
+    return this.measureRun({ runId: t, ...e });
+  }
+  /**
+   * Measure the graph, publish the result, and project the 1.10 view from it.
+   * @param context - Where progress goes, where cancellation arrives, and which run id to
+   *   publish under.
+   * @returns The result, or undefined when there was nothing to measure.
+   * @throws Whatever the context's signal throws once the run has been cancelled, which is a
+   *   `DOMException` named `AbortError`.
+   */
+  async measureRun(e) {
+    const t = this.graph.getDataManager(), n = Array.from(t.nodes.keys());
+    if (n.length === 0)
+      return;
+    const a = Date.now(), i = await this.measure(e, n), o = lt(this.graph), r = dt({
+      ...o === void 0 ? {} : { labelOf: o },
+      runId: e.runId,
+      shape: "node-metric",
+      fields: this.resultFields(),
+      measured: { nodes: n.length, edges: t.edges.size },
+      // The only graph-level field a metric publishes itself. Everything else the shape
+      // promises -- the range, the average, how many elements were measured, how many sit at
+      // the bottom -- is computed from the column the measurement produced.
+      graph: { normalization: i.normalization },
+      nodes: i.nodes,
+      caveats: i.caveats,
+      durationMs: Date.now() - a
+    });
+    return this.#e = r, r;
+  }
+}
+const At = $({
+  plainName: "Bridging",
+  technicalName: "betweenness"
+}), Ee = class Ee extends G {
+  /**
+   * The fields a betweenness result publishes.
+   * @returns The uniform node-metric fields.
+   */
+  resultFields() {
+    return At;
+  }
+  /**
+   * Score every node by the shortest paths that run through it.
+   * @param context - Where progress goes and where cancellation arrives.
+   * @param nodeIds - The nodes to measure.
+   * @returns One raw path count per node, unscaled.
+   */
+  async measure(e, t) {
+    const n = this.algorithmGraph("undirected");
+    e.report({
+      phase: "tracing shortest paths",
+      completed: 0,
+      total: t.length,
+      message: "Brandes runs a breadth-first search from every node."
+    });
+    const a = ut(n);
+    e.signal.throwIfAborted();
+    const i = [];
+    return await F(t, e, "reading scores", (o) => {
+      const r = a[String(o)];
+      i.push({ id: o, values: r === void 0 ? {} : { value: r } });
+    }), {
+      nodes: i,
+      // Raw counts. `options.normalized` is not set, so nothing rescales them.
+      normalization: "none",
+      caveats: {
+        exact: !0,
+        direction: "undirected",
+        weight: null,
+        precision: "f64",
+        method: "brandes",
+        notes: [
+          "Every shortest path is counted exactly, over the graph read as undirected.",
+          "The raw counts are halved, because an undirected shortest path is reached from both ends.",
+          "Path lengths count edges; edge weights are not read."
+        ]
+      }
+    };
+  }
+};
+Ee.namespace = "graphty", Ee.type = "betweenness";
+let le = Ee;
+S.register(le);
+const Bt = {
+  source: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Source Node",
+      description: "Starting node for BFS traversal (uses first node if not set)"
+    }
+  },
+  targetNode: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Target Node",
+      description: "Target node for early termination (optional - searches all nodes if not set)",
+      advanced: !0
+    }
+  }
+}, K = class K extends z {
+  constructor() {
+    super(...arguments), this.legacyOptions = null;
+  }
+  /**
+   * Configure the algorithm with source node
+   * @param options - Configuration options
+   * @param options.source - The source node to start BFS from
+   * @returns This algorithm instance for chaining
+   * @deprecated Use constructor options instead. This method is kept for backward compatibility.
+   */
+  configure(e) {
+    return this.legacyOptions = e, this;
+  }
+  /**
+   * Walk outwards from one node a level at a time.
+   *
+   * A breadth-first walk sorts the graph into layers, so the result is shaped as a layered
+   * grouping: every reached node carries the level it sits on and the position it was reached
+   * in, and the element derives how many nodes share each level and how many levels there are.
+   * A node the walk never reached carries nothing at all -- it is not on level 0, and saying so
+   * would put every unreachable node in the same layer as the source.
+   * @param context - What the element gave the run.
+   * @returns The layered result, or null when there is nothing to walk.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    if (t.length === 0)
+      return null;
+    const n = this._schemaOptions.targetNode ?? void 0, a = this.graph.getDataManager().getSnapshot();
+    if (a.nodeCount === 0)
+      return null;
+    const i = this.legacyOptions?.source ?? this._schemaOptions.source ?? a.ids.idOf(0);
+    if (n !== void 0)
+      return this.legacyWalk(e, t, i, n);
+    const { snapshot: o, run: r } = this.accelerated("breadthFirstSearch", "undirected"), d = this.nodeIndex(o, "source", i);
+    e.report({ phase: "Walking outwards", total: null });
+    const { value: h, precision: m } = await r((p, f) => p.breadthFirstSearch(f, d)), l = /* @__PURE__ */ new Map();
+    for (let p = 0; p < h.visitedCount; p++)
+      l.set(h.order[p], p);
+    const u = [];
+    return await N(e, "Recording levels", t, (p) => {
+      const f = o.ids.indexOf(p), O = f === R ? R : h.depth[f];
+      O !== R && u.push({ id: p, values: { level: O, order: l.get(f) } });
+    }), {
+      shape: "layered-grouping",
+      fields: [...qe, { name: "order", kind: "node", type: "integer" }],
+      nodes: u,
+      caveats: M({
+        method: "bfs",
+        direction: "undirected",
+        weight: null,
+        precision: m,
+        notes: [`Walked outwards from ${String(i)}, which is level 0.`]
+      })
+    };
+  }
+  /**
+   * Walk with an early stop at a target, on the CPU reference implementation.
+   * @param context - What the element gave the run.
+   * @param nodeIds - The nodes to publish for.
+   * @param source - Where the walk starts.
+   * @param targetNode - Where it stops.
+   * @returns The layered result, or null when the source is not in the graph.
+   */
+  async legacyWalk(e, t, n, a) {
+    const i = this.algorithmGraph("undirected");
+    if (!i.hasNode(n))
+      return null;
+    const o = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+    let d = !1;
+    e.report({ phase: "Walking outwards", total: null }), pt(i, n, {
+      targetNode: a,
+      visitCallback: (l, u) => {
+        o.set(l, u), r.set(l, r.size), l === a && (d = !0);
+      }
+    });
+    const h = [];
+    return await N(e, "Recording levels", t, (l) => {
+      const u = o.get(l);
+      u !== void 0 && h.push({ id: l, values: { level: u, order: r.get(l) } });
+    }), {
+      shape: "layered-grouping",
+      fields: [
+        ...qe,
+        { name: "order", kind: "node", type: "integer" },
+        { name: "targetFound", kind: "graph", type: "boolean" }
+      ],
+      nodes: h,
+      graph: { targetFound: d },
+      caveats: M({
+        method: "bfs",
+        direction: "undirected",
+        weight: null,
+        notes: [
+          `Walked outwards from ${String(n)}, which is level 0.`,
+          `Computed on the CPU reference implementation: the walk stops early at ${String(a)}, and no accelerated implementation has an early stop.`
+        ]
+      })
+    };
+  }
+};
+K.namespace = "graphty", K.type = "bfs", K.zodOptionsSchema = Bt, K.optionsSchema = {
+  source: {
+    type: "nodeId",
+    default: null,
+    label: "Source Node",
+    description: "Starting node for BFS traversal (uses first node if not set)",
+    required: !1
+  },
+  targetNode: {
+    type: "nodeId",
+    default: null,
+    label: "Target Node",
+    description: "Target node for early termination (optional - searches all nodes if not set)",
+    required: !1,
+    advanced: !0
+  }
+};
+let de = K;
+S.register(de);
+const De = class De extends z {
+  /**
+   * Pair up the two sides of a two-sided graph so that as many nodes as possible get a partner.
+   *
+   * A matching is a set of edges, so the result is shaped as one: every edge says whether it is
+   * in the pairing and the element counts how many are. The one number the answer is read for
+   * is whether the graph has two sides at all -- a graph that does not cannot be paired up, and
+   * the run says so rather than returning an empty pairing that looks like a bad result.
+   * @param context - What the element gave the run.
+   * @returns The edge set, or null when there are no edges to pair.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().edges.values());
+    if (t.length === 0)
+      return null;
+    const n = this.algorithmGraph("undirected"), a = [
+      ...We("edge", { name: "bipartite", type: "boolean" }),
+      { name: "side", kind: "node", type: "string" },
+      { name: "matched", kind: "node", type: "boolean" }
+    ];
+    e.report({ phase: "Checking for two sides", total: null });
+    const i = mt(n);
+    if (i === null) {
+      const l = [];
+      return await N(e, "Marking the pairing", t, (u) => {
+        l.push({ id: u.id, values: { in: !1 } });
+      }), {
+        shape: "edge-set",
+        fields: a,
+        edges: l,
+        graph: { bipartite: !1 },
+        caveats: M({
+          method: "bipartite-matching",
+          direction: "undirected",
+          weight: null,
+          notes: ["The graph does not have two sides, so nothing could be paired up."]
+        })
+      };
+    }
+    e.report({ phase: "Pairing nodes", total: null });
+    const o = gt(n, {
+      leftNodes: i.left,
+      rightNodes: i.right
+    }), r = /* @__PURE__ */ new Set();
+    for (const [l, u] of o.matching)
+      r.add(T(l, u)), r.add(T(u, l));
+    const d = [];
+    await N(e, "Marking the pairing", t, (l) => {
+      d.push({ id: l.id, values: { in: r.has(T(l.srcId, l.dstId)) } });
+    });
+    const h = new Set(o.matching.values()), m = [];
+    return await N(e, "Marking sides", Array.from(i.left), (l) => {
+      m.push({ id: l, values: { side: "left", matched: o.matching.has(l) } });
+    }), await N(e, "Marking sides", Array.from(i.right), (l) => {
+      m.push({ id: l, values: { side: "right", matched: h.has(l) } });
+    }), {
+      shape: "edge-set",
+      fields: a,
+      nodes: m,
+      edges: d,
+      graph: { bipartite: !0 },
+      caveats: M({
+        method: "bipartite-matching",
+        direction: "undirected",
+        weight: null,
+        notes: [`${String(o.size)} of the two sides' nodes found a partner.`]
+      })
+    };
+  }
+};
+De.namespace = "graphty", De.type = "bipartite-matching";
+let he = De;
+S.register(he);
+const Yt = $({
+  plainName: "Reach",
+  technicalName: "closeness"
+}), Pe = class Pe extends G {
+  /**
+   * The fields a closeness result publishes.
+   * @returns The uniform node-metric fields.
+   */
+  resultFields() {
+    return Yt;
+  }
+  /**
+   * Score every node by how short its paths to the rest of the graph are.
+   * @param context - Where progress goes and where cancellation arrives.
+   * @param nodeIds - The nodes to measure.
+   * @returns One score per node, unscaled.
+   */
+  async measure(e, t) {
+    const n = this.algorithmGraph("undirected");
+    e.report({
+      phase: "measuring distances",
+      completed: 0,
+      total: t.length,
+      message: "A breadth-first search runs from every node."
+    });
+    const a = ft(n);
+    e.signal.throwIfAborted();
+    const i = [];
+    return await F(t, e, "reading scores", (o) => {
+      const r = a[String(o)];
+      i.push({ id: o, values: r === void 0 ? {} : { value: r } });
+    }), {
+      nodes: i,
+      // The algorithm's own figure, published as it was computed.
+      normalization: "none",
+      caveats: {
+        exact: !0,
+        direction: "undirected",
+        weight: null,
+        precision: "f64",
+        method: "closeness-bfs",
+        notes: [
+          "Distances are exact, measured over the graph read as undirected.",
+          "Distance counts edges; edge weights are not read.",
+          "A score is the reciprocal of the total distance to the nodes this one can reach, with no correction for how many that is, so a node in a small component scores as though it reached the whole graph."
+        ]
+      }
+    };
+  }
+};
+Pe.namespace = "graphty", Pe.type = "closeness";
+let ue = Pe;
+S.register(ue);
+const Re = class Re extends z {
+  /**
+   * Find the separate pieces of the graph.
+   *
+   * A piece is a group in the community shape's sense -- two nodes are in the same one when a
+   * path joins them -- so this publishes the same `group` per node that every grouping method
+   * does, and no modularity, which is not defined for a partition nothing optimised.
+   * @param context - What the element gave the run.
+   * @returns The community result, or null when there are no nodes to group.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    if (t.length === 0)
+      return null;
+    const { snapshot: n, run: a } = this.accelerated("connectedComponents", "undirected"), { ids: i } = n;
+    e.report({ phase: "Finding pieces", total: null });
+    const { value: o, precision: r } = await a((h, m) => h.connectedComponents(m)), d = [];
+    return await N(e, "Grouping nodes", t, (h) => {
+      const m = i.indexOf(h);
+      d.push({ id: h, values: { group: o.labels[m] ?? 0 } });
+    }), {
+      shape: "community",
+      fields: _(!1),
+      nodes: d,
+      caveats: M({
+        method: "connected-components",
+        direction: "undirected",
+        weight: null,
+        precision: r,
+        notes: ["Strength: weak. An edge joins its two nodes whichever way it was declared."]
+      })
+    };
+  }
+};
+Re.namespace = "graphty", Re.type = "connected-components";
+let pe = Re;
+S.register(pe);
+const Zt = [
+  ...$({ plainName: "Connections", technicalName: "degree", type: "integer", unit: "links" }),
+  oe({
+    name: "inDegree",
+    plainName: "Incoming connections",
+    technicalName: "inDegree",
+    kind: "node",
+    type: "integer"
+  }),
+  oe({
+    name: "outDegree",
+    plainName: "Outgoing connections",
+    technicalName: "outDegree",
+    kind: "node",
+    type: "integer"
+  })
+], Fe = class Fe extends G {
+  /**
+   * The fields a degree result publishes.
+   * @returns The uniform node-metric fields, plus `inDegree` and `outDegree`.
+   */
+  resultFields() {
+    return Zt;
+  }
+  /**
+   * Count every node's edges.
+   * @param context - Where progress goes and where cancellation arrives.
+   * @param nodeIds - The nodes to measure.
+   * @returns One count per node, unscaled.
+   */
+  async measure(e, t) {
+    const n = this.algorithmGraph("directed"), a = [];
+    return await F(t, e, "counting connections", (i) => {
+      const o = n.inDegree(i), r = n.outDegree(i);
+      a.push({ id: i, values: { value: o + r, inDegree: o, outDegree: r } });
+    }), {
+      nodes: a,
+      // A count of edges, published as it was counted.
+      normalization: "none",
+      caveats: {
+        exact: !0,
+        direction: "directed",
+        weight: null,
+        precision: "f64",
+        method: "degree",
+        notes: ["Counted over the graph as the records declared it, so a node's total is its incoming edges plus its outgoing ones."]
+      }
+    };
+  }
+};
+Fe.namespace = "graphty", Fe.type = "degree";
+let me = Fe;
+S.register(me);
+const Xt = {
+  source: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Source Node",
+      description: "Starting node for DFS traversal (uses first node if not set)"
+    }
+  },
+  targetNode: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Target Node",
+      description: "Target node for early termination (optional - searches all nodes if not set)",
+      advanced: !0
+    }
+  },
+  recursive: {
+    schema: c.boolean().default(!1),
+    meta: {
+      label: "Recursive",
+      description: "Use recursive implementation instead of iterative (may cause stack overflow on large graphs)",
+      advanced: !0
+    }
+  },
+  preOrder: {
+    schema: c.boolean().default(!0),
+    meta: {
+      label: "Pre-Order",
+      description: "Visit nodes before their children (pre-order) vs after (post-order)",
+      advanced: !0
+    }
+  }
+}, L = class L extends z {
+  constructor() {
+    super(...arguments), this.legacyOptions = null;
+  }
+  /**
+   * Configure the algorithm with source node
+   * @param options - Configuration options
+   * @param options.source - The source node to start DFS from
+   * @returns This algorithm instance for chaining
+   * @deprecated Use constructor options instead. This method is kept for backward compatibility.
+   */
+  configure(e) {
+    return this.legacyOptions = e, this;
+  }
+  /**
+   * Walk as deep as possible from one node before backtracking.
+   *
+   * What a depth-first walk produces is one number per node -- the position it was reached in
+   * -- so the result is a node metric, and the ranking and range of that column come from the
+   * element rather than from here. A node the walk never reached carries no position, and says
+   * so with `visited`, because "not reached" and "reached first" are not the same answer.
+   * @param context - What the element gave the run.
+   * @returns The exploration order, or null when there is nothing to walk.
+   */
+  async compute(e) {
+    const t = this.graph.getDataManager(), n = Array.from(t.nodes.keys());
+    if (n.length === 0)
+      return null;
+    const a = this.legacyOptions?.source ?? this._schemaOptions.source ?? n[0], { targetNode: i, recursive: o, preOrder: r } = this._schemaOptions;
+    if (!t.nodes.has(a))
+      return null;
+    const d = this.algorithmGraph("undirected");
+    e.report({ phase: "Walking deep", total: null });
+    const h = yt(d, a, {
+      targetNode: i ?? void 0,
+      recursive: o,
+      preOrder: r
+    }), m = /* @__PURE__ */ new Map();
+    h.order.forEach((u, p) => m.set(u, p));
+    const l = [];
+    return await N(e, "Recording the order", n, (u) => {
+      const p = m.get(u);
+      l.push({ id: u, values: { value: p, visited: h.visited.has(u) } });
+    }), {
+      shape: "node-metric",
+      fields: [...je("node", "integer"), { name: "visited", kind: "node", type: "boolean" }],
+      nodes: l,
+      caveats: M({
+        method: "dfs",
+        direction: "undirected",
+        weight: null,
+        notes: [`Walked from ${String(a)}, ${r ? "recording each node as it was reached" : "recording each node as it was left"}.`]
+      })
+    };
+  }
+};
+L.namespace = "graphty", L.type = "dfs", L.zodOptionsSchema = Xt, L.optionsSchema = {
+  source: {
+    type: "nodeId",
+    default: null,
+    label: "Source Node",
+    description: "Starting node for DFS traversal (uses first node if not set)",
+    required: !1
+  },
+  targetNode: {
+    type: "nodeId",
+    default: null,
+    label: "Target Node",
+    description: "Target node for early termination (optional - searches all nodes if not set)",
+    required: !1,
+    advanced: !0
+  },
+  recursive: {
+    type: "boolean",
+    default: !1,
+    label: "Recursive",
+    description: "Use recursive implementation instead of iterative (may cause stack overflow on large graphs)",
+    advanced: !0
+  },
+  preOrder: {
+    type: "boolean",
+    default: !0,
+    label: "Pre-Order",
+    description: "Visit nodes before their children (pre-order) vs after (post-order)",
+    advanced: !0
+  }
+};
+let ge = L;
+S.register(ge);
+const Jt = {
+  source: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Source Node",
+      description: "Starting node for shortest path (uses first node if not set)"
+    }
+  },
+  target: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Target Node",
+      description: "Destination node for shortest path (uses last node if not set)"
+    }
+  },
+  bidirectional: {
+    schema: c.boolean().default(!0),
+    meta: {
+      label: "Bidirectional Search",
+      description: "Accepted and ignored: the shortest-path search relaxes outwards from the source in one direction, and the route it finds is the same one either way",
+      advanced: !0
+    }
+  }
+}, U = class U extends z {
+  constructor() {
+    super(...arguments), this.legacyOptions = null;
+  }
+  /**
+   * Configure the algorithm with source and optional target nodes
+   * @param options - Configuration options
+   * @param options.source - The source node for shortest path computation
+   * @param options.target - The target node (optional)
+   * @returns This algorithm instance for chaining
+   * @deprecated Use constructor options instead. This method is kept for backward compatibility.
+   */
+  configure(e) {
+    return this.legacyOptions = e, this;
+  }
+  /**
+   * Find the cheapest route from the source to the target.
+   *
+   * Publishes the path shape's uniform fields: whether each node and edge is on the route,
+   * where each node sits along it counting the source as 0, and the route's size and cost. It
+   * also publishes how far every reachable node is from the source, which is what makes one
+   * run answer both "show me the way there" and "how far is everything".
+   * @param context - What the element gave the run.
+   * @returns The route, or null when there are no nodes to search.
+   */
+  async compute(e) {
+    const t = this.graph.getDataManager(), n = Array.from(t.nodes.keys());
+    if (n.length === 0)
+      return null;
+    const { snapshot: a, edgeRemap: i, run: o } = this.accelerated("sssp", "undirected");
+    if (a.nodeCount === 0)
+      return null;
+    const { ids: r } = a, d = this.legacyOptions?.source ?? this._schemaOptions.source ?? r.idOf(0), h = this.legacyOptions?.target ?? this._schemaOptions.target ?? r.idOf(a.nodeCount - 1), m = this.nodeIndex(a, "source", d), l = this.nodeIndex(a, "target", h);
+    e.report({ phase: "Searching for the route", total: null });
+    const { value: u, precision: p } = await o((w, v) => w.sssp(v, m)), f = u.pathTo(l), O = new Set(u.pathEdges(l)), y = /* @__PURE__ */ new Map();
+    f.forEach((w, v) => y.set(w, v));
+    const k = [];
+    await N(e, "Marking the route", n, (w) => {
+      const v = r.indexOf(w), b = v === R ? void 0 : y.get(v);
+      k.push({
+        id: w,
+        values: {
+          onPath: b !== void 0,
+          order: b,
+          distance: v === R ? 1 / 0 : u.dist[v]
+        }
+      });
+    });
+    const I = [];
+    return await N(e, "Marking the route", Array.from(t.edges.values()), (w) => {
+      const v = i === null ? w.index : i[w.index] ?? R;
+      I.push({ id: w.id, values: { onPath: O.has(v) } });
+    }), {
+      shape: "path",
+      fields: [...Qe, { name: "distance", kind: "node", type: "number" }],
+      nodes: k,
+      edges: I,
+      graph: {
+        length: f.length,
+        cost: f.length === 0 ? 0 : u.dist[l],
+        hops: Math.max(f.length - 1, 0)
+      },
+      caveats: M({
+        method: "dijkstra",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "distance" },
+        precision: p,
+        notes: f.length === 0 ? [`No route runs from ${String(d)} to ${String(h)}.`] : [`Route from ${String(d)} to ${String(h)}.`]
+      })
+    };
+  }
+};
+U.namespace = "graphty", U.type = "dijkstra", U.zodOptionsSchema = Jt, U.optionsSchema = {
+  source: {
+    type: "nodeId",
+    default: null,
+    label: "Source Node",
+    description: "Starting node for shortest path (uses first node if not set)",
+    required: !1
+  },
+  target: {
+    type: "nodeId",
+    default: null,
+    label: "Target Node",
+    description: "Destination node for shortest path (uses last node if not set)",
+    required: !1
+  },
+  bidirectional: {
+    type: "boolean",
+    default: !0,
+    label: "Bidirectional Search",
+    description: "Accepted and ignored: the shortest-path search relaxes outwards from the source in one direction, and the route it finds is the same one either way",
+    advanced: !0
+  }
+};
+let fe = U;
+S.register(fe);
+const Qt = {
+  maxIterations: {
+    schema: c.number().int().min(1).max(1e4).default(1e3),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum power iterations",
+      advanced: !0
+    }
+  },
+  tolerance: {
+    schema: c.number().min(1e-10).max(0.01).default(1e-6),
+    meta: {
+      label: "Tolerance",
+      description: "Convergence threshold",
+      advanced: !0
+    }
+  },
+  normalized: {
+    schema: c.boolean().default(!0),
+    meta: {
+      label: "Normalized",
+      description: "Whether to normalize the final scores",
+      advanced: !0
+    }
+  },
+  mode: {
+    schema: c.enum(["in", "out", "total"]).default("total"),
+    meta: {
+      label: "Direction Mode",
+      description: "Direction mode for directed graphs",
+      advanced: !0
+    }
+  },
+  endpoints: {
+    schema: c.boolean().default(!1),
+    meta: {
+      label: "Include Endpoints",
+      description: "Whether to include endpoints in path calculations",
+      advanced: !0
+    }
+  }
+}, _t = $({
+  plainName: "Influence by association",
+  technicalName: "eigenvector score"
+}), P = class P extends G {
+  /**
+   * The fields an eigenvector result publishes.
+   * @returns The uniform node-metric fields.
+   */
+  resultFields() {
+    return _t;
+  }
+  /**
+   * Score every node by the influence of its neighbours.
+   * @param context - Where progress goes and where cancellation arrives.
+   * @param nodeIds - The nodes to measure.
+   * @returns One score per node, scaled as the options asked for.
+   */
+  async measure(e, t) {
+    const { maxIterations: n, tolerance: a, normalized: i, mode: o, endpoints: r } = this.schemaOptions, d = this._schemaOptions.startVector ?? void 0, h = this.algorithmGraph("undirected");
+    e.report({
+      phase: "iterating",
+      completed: 0,
+      total: t.length,
+      message: `Power iteration, up to ${String(n)} passes.`
+    });
+    let m;
+    try {
+      m = bt(h, {
+        normalized: i,
+        maxIterations: n,
+        tolerance: a,
+        mode: o,
+        endpoints: r,
+        startVector: d
+      });
+    } catch (u) {
+      if (!(u instanceof wt))
+        throw u;
+      const p = `${P.namespace}:${P.type}`;
+      throw new et({
+        code: "E_NOT_CONVERGED",
+        message: `Eigenvector centrality did not converge in ${String(n)} iterations (tolerance ${String(a)}). Raise the maxIterations param (up to 10000), or loosen tolerance, and run it again.`,
+        source: "run",
+        target: { kind: "run", id: e.runId },
+        details: { algorithm: p, maxIterations: n, tolerance: a },
+        cause: u
+      });
+    }
+    e.signal.throwIfAborted();
+    const l = [];
+    return await F(t, e, "reading scores", (u) => {
+      const p = m[String(u)];
+      l.push({ id: u, values: p === void 0 ? {} : { value: p } });
+    }), {
+      nodes: l,
+      // With `normalized`, the algorithm rescales its eigenvector so the lowest score is 0
+      // and the highest is 1. Without it the raw unit-length eigenvector is published.
+      normalization: i ? "min-max" : "none",
+      caveats: {
+        exact: !0,
+        direction: "undirected",
+        weight: null,
+        precision: "f64",
+        method: "power-iteration",
+        // Measured, not assumed: the algorithm throws when it hits its iteration cap, and
+        // that becomes E_NOT_CONVERGED above, so a result exists only when it converged.
+        converged: !0,
+        notes: [
+          `Power iteration reached a tolerance of ${String(a)} within ${String(n)} passes.`,
+          "Edge weights are not read."
+        ]
+      }
+    };
+  }
+};
+P.namespace = "graphty", P.type = "eigenvector", P.zodOptionsSchema = Qt, P.optionsSchema = {
+  maxIterations: {
+    type: "integer",
+    default: 1e3,
+    label: "Max Iterations",
+    description: "Maximum power iterations",
+    min: 1,
+    max: 1e4,
+    advanced: !0
+  },
+  tolerance: {
+    type: "number",
+    default: 1e-6,
+    label: "Tolerance",
+    description: "Convergence threshold",
+    min: 1e-10,
+    max: 0.01,
+    advanced: !0
+  },
+  normalized: {
+    type: "boolean",
+    default: !0,
+    label: "Normalized",
+    description: "Whether to normalize the final scores",
+    advanced: !0
+  },
+  mode: {
+    type: "select",
+    default: "total",
+    label: "Direction Mode",
+    description: "Direction mode for directed graphs",
+    options: [
+      { value: "total", label: "Total (both directions)" },
+      { value: "in", label: "In-degree (incoming edges)" },
+      { value: "out", label: "Out-degree (outgoing edges)" }
+    ],
+    advanced: !0
+  },
+  endpoints: {
+    type: "boolean",
+    default: !1,
+    label: "Include Endpoints",
+    description: "Whether to include endpoints in path calculations",
+    advanced: !0
+  }
+  // Note: startVector is a Map type - programmatic only, not in schema
+};
+let ye = P;
+S.register(ye);
+const $e = class $e extends z {
+  /**
+   * Measure the distance between every pair of nodes, and give each node the distance to the
+   * node furthest from it.
+   *
+   * Asked for every pair, the shortest-path question stops being one route: there is no route
+   * here to put an `onPath` on. What it produces instead is a measurement of every node -- its
+   * eccentricity, the distance to the furthest node it can reach -- so the result is shaped as
+   * a node metric, and the widest and narrowest of those distances, the graph's diameter and
+   * radius, ride along as facts about the whole graph.
+   *
+   * THE SHAPE IS WHAT MAKES IT PAINTABLE. A shape of "fact" declares no per-element field, so
+   * the element would have had nothing to colour by and a consumer asking to encode
+   * eccentricity on node colour would have been refused -- with no way to do it by hand
+   * either, which is the case that has to be fixed here rather than worked around outside.
+   * @param context - What the element gave the run.
+   * @returns The all-pairs measurement, or null when there are no nodes to measure.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    if (t.length === 0)
+      return null;
+    const n = this.algorithmGraph("undirected");
+    e.report({ phase: "Measuring every pair", total: null });
+    const a = vt(n), i = /* @__PURE__ */ new Map();
+    await N(e, "Measuring reach", t, (h) => {
+      const m = a.distances.get(h);
+      if (m === void 0) {
+        i.set(h, 1 / 0);
+        return;
+      }
+      let l = 0;
+      for (const u of m.values())
+        isFinite(u) && u > l && (l = u);
+      i.set(h, l);
+    });
+    let o = 0, r = 1 / 0;
+    for (const h of i.values())
+      isFinite(h) && (o = Math.max(o, h), r = Math.min(r, h));
+    r === 1 / 0 && (r = 0);
+    const d = [];
+    return await N(e, "Publishing distances", t, (h) => {
+      const m = i.get(h) ?? 1 / 0;
+      isFinite(m) && d.push({ id: h, values: { value: m } });
+    }), {
+      shape: "node-metric",
+      fields: [
+        ...je("node"),
+        { name: "diameter", kind: "graph", type: "number" },
+        { name: "radius", kind: "graph", type: "number" },
+        { name: "hasNegativeCycle", kind: "graph", type: "boolean" }
+      ],
+      nodes: d,
+      graph: { diameter: o, radius: r, hasNegativeCycle: a.hasNegativeCycle },
+      caveats: M({
+        method: "floyd-warshall",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "distance" },
+        notes: [
+          "Every pair was measured. Each node's value is its eccentricity: the distance to the furthest node it can reach."
+        ]
+      })
+    };
+  }
+};
+$e.namespace = "graphty", $e.type = "floyd-warshall";
+let be = $e;
+S.register(be);
+const ea = {
+  maxCommunities: {
+    schema: c.number().int().min(0).max(100).default(0),
+    meta: {
+      label: "Max Communities",
+      description: "Stop when this many communities reached (0 = find optimal)"
+    }
+  },
+  minCommunitySize: {
+    schema: c.number().int().min(1).max(100).default(1),
+    meta: {
+      label: "Min Community Size",
+      description: "Minimum nodes per community",
+      advanced: !0
+    }
+  },
+  maxIterations: {
+    schema: c.number().int().min(1).max(1e4).default(1e3),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum edge removal iterations before stopping",
+      advanced: !0
+    }
+  }
+}, j = class j extends z {
+  /**
+   * Group the nodes into communities by cutting the edges the most routes run through.
+   *
+   * The method produces a dendrogram -- one partition per cut -- and the run publishes the cut
+   * that scored the highest modularity, with that score. A graph with no edges falls apart at
+   * the first step, and every node is then its own community.
+   * @param context - What the element gave the run.
+   * @returns The community result, or null when there are no nodes to group.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    if (t.length === 0)
+      return null;
+    const { maxCommunities: n, minCommunitySize: a, maxIterations: i } = this.schemaOptions, o = this.algorithmGraph("undirected");
+    e.report({ phase: "Cutting bridges", total: null });
+    const r = Nt(o, {
+      maxCommunities: n > 0 ? n : void 0,
+      minCommunitySize: a,
+      maxIterations: i
+    }), d = n > 0 ? r.filter((p) => p.communities.length <= n) : r, m = (d.length > 0 ? d : r.slice(0, 1)).reduce(
+      (p, f) => p === void 0 || f.modularity > p.modularity ? f : p,
+      void 0
+    ), l = /* @__PURE__ */ new Map();
+    if (m !== void 0)
+      for (let p = 0; p < m.communities.length; p++)
+        for (const f of m.communities[p])
+          l.set(f, p);
+    else
+      t.forEach((p, f) => l.set(p, f));
+    const u = [];
+    return await N(e, "Grouping nodes", t, (p) => {
+      u.push({ id: p, values: { group: l.get(p) ?? 0 } });
+    }), {
+      shape: "community",
+      fields: _(!0),
+      nodes: u,
+      graph: { modularity: m?.modularity ?? 0 },
+      caveats: M({
+        method: "girvan-newman",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "strength" },
+        notes: m === void 0 ? ["No edge could be cut, so every node is its own community."] : [`Kept the best of ${String(r.length)} successive cuts.`]
+      })
+    };
+  }
+};
+j.namespace = "graphty", j.type = "girvan-newman", j.zodOptionsSchema = ea, j.optionsSchema = {
+  maxCommunities: {
+    type: "integer",
+    default: 0,
+    label: "Max Communities",
+    description: "Stop when this many communities reached (0 = find optimal)",
+    min: 0,
+    max: 100
+  },
+  minCommunitySize: {
+    type: "integer",
+    default: 1,
+    label: "Min Community Size",
+    description: "Minimum nodes per community",
+    min: 1,
+    max: 100,
+    advanced: !0
+  },
+  maxIterations: {
+    type: "integer",
+    default: 1e3,
+    label: "Max Iterations",
+    description: "Maximum edge removal iterations before stopping",
+    min: 1,
+    max: 1e4,
+    advanced: !0
+  }
+};
+let we = j;
+S.register(we);
+const ta = {
+  maxIterations: {
+    schema: c.number().int().min(1).max(1e3).default(100),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum iterations for hub/authority computation",
+      advanced: !0
+    }
+  },
+  tolerance: {
+    schema: c.number().min(1e-10).max(0.01).default(1e-6),
+    meta: {
+      label: "Tolerance",
+      description: "Convergence threshold",
+      advanced: !0
+    }
+  },
+  normalized: {
+    schema: c.boolean().default(!0),
+    meta: {
+      label: "Normalized",
+      description: "Whether to normalize the final hub/authority scores",
+      advanced: !0
+    }
+  },
+  mode: {
+    schema: c.enum(["in", "out", "total"]).default("total"),
+    meta: {
+      label: "Direction Mode",
+      description: "Direction mode for directed graphs",
+      advanced: !0
+    }
+  },
+  endpoints: {
+    schema: c.boolean().default(!1),
+    meta: {
+      label: "Include Endpoints",
+      description: "Whether to include endpoints in path calculations",
+      advanced: !0
+    }
+  }
+}, aa = [
+  ...$({ plainName: "Hub and authority", technicalName: "combined HITS score" }),
+  oe({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
+  oe({
+    name: "authority",
+    plainName: "Authority",
+    technicalName: "authority score",
+    kind: "node",
+    type: "number"
+  })
+], V = class V extends G {
+  /**
+   * The fields a HITS result publishes.
+   * @returns The uniform node-metric fields, plus `hub` and `authority`.
+   */
+  resultFields() {
+    return aa;
+  }
+  /**
+   * Score every node as a hub and as an authority.
+   * @param context - Where progress goes and where cancellation arrives.
+   * @param nodeIds - The nodes to measure.
+   * @returns The combined score per node, with the two halves beside it.
+   */
+  async measure(e, t) {
+    const { maxIterations: n, tolerance: a, normalized: i, mode: o, endpoints: r } = this.schemaOptions, d = this.algorithmGraph("directed");
+    e.report({
+      phase: "iterating",
+      completed: 0,
+      total: t.length,
+      message: `Hub and authority scores refine each other, up to ${String(n)} passes.`
+    });
+    const h = kt(d, {
+      maxIterations: n,
+      tolerance: a,
+      normalized: i,
+      mode: o,
+      endpoints: r
+    });
+    e.signal.throwIfAborted();
+    const m = [];
+    return await F(t, e, "reading scores", (l) => {
+      const u = h.hubs[String(l)], p = h.authorities[String(l)];
+      if (u === void 0 || p === void 0) {
+        m.push({ id: l, values: {} });
+        return;
+      }
+      m.push({ id: l, values: { value: (u + p) / 2, hub: u, authority: p } });
+    }), {
+      nodes: m,
+      // The combined score is the average of two vectors the algorithm scaled, which leaves
+      // it scaled by neither of the two rules this field names. The notes say what was done.
+      normalization: "none",
+      caveats: {
+        exact: !0,
+        direction: "directed",
+        weight: null,
+        precision: "f64",
+        method: "hits",
+        // `converged` and `iterations` are deliberately absent: the implementation stops
+        // either at its tolerance or at its iteration cap and reports neither.
+        notes: [
+          "The published value is the average of this node's hub score and its authority score.",
+          i ? "The hub and authority vectors each have unit length, which is how the iteration leaves them." : "The hub and authority vectors were each divided by their own highest score.",
+          `Iteration stops at a tolerance of ${String(a)} or after ${String(n)} passes, whichever comes first.`,
+          "Whether it reached the tolerance is not reported by the implementation, so this run cannot say whether it converged.",
+          "Edge weights are not read."
+        ]
+      }
+    };
+  }
+};
+V.namespace = "graphty", V.type = "hits", V.zodOptionsSchema = ta, V.optionsSchema = {
+  maxIterations: {
+    type: "integer",
+    default: 100,
+    label: "Max Iterations",
+    description: "Maximum iterations for hub/authority computation",
+    min: 1,
+    max: 1e3,
+    advanced: !0
+  },
+  tolerance: {
+    type: "number",
+    default: 1e-6,
+    label: "Tolerance",
+    description: "Convergence threshold",
+    min: 1e-10,
+    max: 0.01,
+    advanced: !0
+  },
+  normalized: {
+    type: "boolean",
+    default: !0,
+    label: "Normalized",
+    description: "Whether to normalize the final hub/authority scores",
+    advanced: !0
+  },
+  mode: {
+    type: "select",
+    default: "total",
+    label: "Direction Mode",
+    description: "Direction mode for directed graphs",
+    options: [
+      { value: "total", label: "Total (both directions)" },
+      { value: "in", label: "In-degree (incoming edges)" },
+      { value: "out", label: "Out-degree (outgoing edges)" }
+    ],
+    advanced: !0
+  },
+  endpoints: {
+    type: "boolean",
+    default: !1,
+    label: "Include Endpoints",
+    description: "Whether to include endpoints in path calculations",
+    advanced: !0
+  }
+};
+let ve = V;
+S.register(ve);
+const na = {
+  alpha: {
+    schema: c.number().min(0.01).max(0.5).default(0.1),
+    meta: {
+      label: "Alpha (Attenuation)",
+      description: "Attenuation factor - must be less than 1/λmax",
+      step: 0.01
+    }
+  },
+  beta: {
+    schema: c.number().min(0).max(10).default(1),
+    meta: {
+      label: "Beta (Base Weight)",
+      description: "Base centrality added to each node",
+      step: 0.1,
+      advanced: !0
+    }
+  },
+  maxIterations: {
+    schema: c.number().int().min(1).max(1e3).default(100),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum iterations",
+      advanced: !0
+    }
+  },
+  tolerance: {
+    schema: c.number().min(1e-10).max(0.01).default(1e-6),
+    meta: {
+      label: "Tolerance",
+      description: "Convergence threshold",
+      advanced: !0
+    }
+  },
+  normalized: {
+    schema: c.boolean().default(!0),
+    meta: {
+      label: "Normalized",
+      description: "Whether to normalize the final scores",
+      advanced: !0
+    }
+  },
+  mode: {
+    schema: c.enum(["in", "out", "total"]).default("total"),
+    meta: {
+      label: "Direction Mode",
+      description: "Direction mode for directed graphs",
+      advanced: !0
+    }
+  },
+  endpoints: {
+    schema: c.boolean().default(!1),
+    meta: {
+      label: "Include Endpoints",
+      description: "Whether to include endpoints in path calculations",
+      advanced: !0
+    }
+  }
+}, ia = $({
+  plainName: "Influence at a distance",
+  technicalName: "Katz score"
+}), q = class q extends G {
+  /**
+   * The fields a Katz result publishes.
+   * @returns The uniform node-metric fields.
+   */
+  resultFields() {
+    return ia;
+  }
+  /**
+   * Score every node by the paths that reach it.
+   * @param context - Where progress goes and where cancellation arrives.
+   * @param nodeIds - The nodes to measure.
+   * @returns One score per node, scaled as the options asked for.
+   */
+  async measure(e, t) {
+    const { alpha: n, beta: a, maxIterations: i, tolerance: o, normalized: r, mode: d, endpoints: h } = this.schemaOptions, m = this.algorithmGraph("undirected");
+    e.report({
+      phase: "iterating",
+      completed: 0,
+      total: t.length,
+      message: `Attenuated path sums, up to ${String(i)} passes.`
+    });
+    const l = St(m, {
+      normalized: r,
+      alpha: n,
+      beta: a,
+      maxIterations: i,
+      tolerance: o,
+      mode: d,
+      endpoints: h
+    });
+    e.signal.throwIfAborted();
+    const u = [];
+    return await F(t, e, "reading scores", (p) => {
+      const f = l[String(p)];
+      u.push({ id: p, values: f === void 0 ? {} : { value: f } });
+    }), {
+      nodes: u,
+      // With `normalized`, the algorithm rescales so the lowest score is 0 and the highest
+      // is 1. Without it the raw attenuated sums are published.
+      normalization: r ? "min-max" : "none",
+      caveats: {
+        exact: !0,
+        direction: "undirected",
+        weight: null,
+        precision: "f64",
+        method: "katz-iteration",
+        // `converged` and `iterations` are deliberately absent: the implementation stops
+        // either at its tolerance or at its iteration cap and reports neither.
+        notes: [
+          `Every node starts with a base influence of ${String(a)}, and a path of length k contributes ${String(n)} to the power k.`,
+          `Iteration stops at a tolerance of ${String(o)} or after ${String(i)} passes, whichever comes first.`,
+          "Whether it reached the tolerance is not reported by the implementation, so this run cannot say whether it converged.",
+          "Edge weights are not read."
+        ]
+      }
+    };
+  }
+};
+q.namespace = "graphty", q.type = "katz", q.zodOptionsSchema = na, q.optionsSchema = {
+  alpha: {
+    type: "number",
+    default: 0.1,
+    label: "Alpha (Attenuation)",
+    description: "Attenuation factor - must be less than 1/λmax",
+    min: 0.01,
+    max: 0.5,
+    step: 0.01
+  },
+  beta: {
+    type: "number",
+    default: 1,
+    label: "Beta (Base Weight)",
+    description: "Base centrality added to each node",
+    min: 0,
+    max: 10,
+    step: 0.1,
+    advanced: !0
+  },
+  maxIterations: {
+    type: "integer",
+    default: 100,
+    label: "Max Iterations",
+    description: "Maximum iterations",
+    min: 1,
+    max: 1e3,
+    advanced: !0
+  },
+  tolerance: {
+    type: "number",
+    default: 1e-6,
+    label: "Tolerance",
+    description: "Convergence threshold",
+    min: 1e-10,
+    max: 0.01,
+    advanced: !0
+  },
+  normalized: {
+    type: "boolean",
+    default: !0,
+    label: "Normalized",
+    description: "Whether to normalize the final scores",
+    advanced: !0
+  },
+  mode: {
+    type: "select",
+    default: "total",
+    label: "Direction Mode",
+    description: "Direction mode for directed graphs",
+    options: [
+      { value: "total", label: "Total (both directions)" },
+      { value: "in", label: "In-degree (incoming edges)" },
+      { value: "out", label: "Out-degree (outgoing edges)" }
+    ],
+    advanced: !0
+  },
+  endpoints: {
+    type: "boolean",
+    default: !1,
+    label: "Include Endpoints",
+    description: "Whether to include endpoints in path calculations",
+    advanced: !0
+  }
+};
+let Ne = q;
+S.register(Ne);
+const Ge = class Ge extends z {
+  /**
+   * Find the cheapest set of edges that still joins every node.
+   *
+   * A spanning tree is a set of edges, so the result is shaped as one: every edge says whether
+   * it is in the network, the element counts how many are, and the run publishes the one number
+   * the answer is actually read for -- what the network costs in total.
+   * @param context - What the element gave the run.
+   * @returns The edge set, or null when there are no edges to choose from.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().edges.values());
+    if (t.length === 0)
+      return null;
+    const { edgeRemap: n, run: a } = this.accelerated("minimumSpanningTree", "undirected");
+    e.report({ phase: "Choosing edges", total: null });
+    const { value: i, precision: o } = await a((h, m) => h.minimumSpanningTree(m)), r = new Set(i.edges), d = [];
+    return await N(e, "Marking the network", t, (h) => {
+      const m = n === null ? h.index : n[h.index] ?? R;
+      d.push({ id: h.id, values: { in: r.has(m) } });
+    }), {
+      shape: "edge-set",
+      fields: We("edge", { name: "totalWeight", type: "number" }),
+      edges: d,
+      graph: { totalWeight: i.totalWeight },
+      caveats: M({
+        method: "kruskal",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "distance" },
+        precision: o,
+        notes: [`The tree joins the graph with ${String(i.edges.length)} edges.`]
+      })
+    };
+  }
+};
+Ge.namespace = "graphty", Ge.type = "kruskal";
+let ke = Ge;
+S.register(ke);
+const sa = {
+  maxIterations: {
+    schema: c.number().int().min(1).max(500).default(100),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum label propagation rounds"
+    }
+  },
+  randomSeed: {
+    schema: c.number().int().min(0).max(2147483647).default(42),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible tie-breaking",
+      advanced: !0
+    }
+  }
+}, A = class A extends z {
+  /**
+   * Group the nodes into communities by letting labels spread between neighbours.
+   *
+   * Publishes a group per node and nothing the shape does not derive. Label propagation does
+   * not score its own partition, so it reports no modularity: the community shape makes that
+   * field optional for exactly this reason, and a number invented to fill it would be read as
+   * a measurement.
+   * @param context - What the element gave the run.
+   * @returns The community result, or null when there are no nodes to group.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    if (t.length === 0)
+      return null;
+    const { maxIterations: n, randomSeed: a } = this.schemaOptions, i = this.algorithmGraph("undirected");
+    e.report({ phase: "Spreading labels", total: null });
+    const o = Ot(i, {
+      maxIterations: n,
+      randomSeed: a
+    }), r = [];
+    return await N(e, "Grouping nodes", t, (d) => {
+      r.push({ id: d, values: { group: o.communities.get(String(d)) ?? 0 } });
+    }), {
+      shape: "community",
+      fields: _(!1),
+      nodes: r,
+      caveats: M({
+        method: "label-propagation",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "strength" },
+        converged: o.converged,
+        iterations: o.iterations,
+        seed: a,
+        notes: ["Label propagation does not score its own partition, so it reports no modularity."]
+      })
+    };
+  }
+};
+A.namespace = "graphty", A.type = "label-propagation", A.zodOptionsSchema = sa, A.optionsSchema = {
+  maxIterations: {
+    type: "integer",
+    default: 100,
+    label: "Max Iterations",
+    description: "Maximum label propagation rounds",
+    min: 1,
+    max: 500
+  },
+  randomSeed: {
+    type: "integer",
+    default: 42,
+    label: "Random Seed",
+    description: "Seed for reproducible tie-breaking",
+    min: 0,
+    max: 2147483647,
+    advanced: !0
+  }
+};
+let Se = A;
+S.register(Se);
+const oa = {
+  resolution: {
+    schema: c.number().min(0.1).max(5).default(1),
+    meta: {
+      label: "Resolution",
+      description: "Controls community granularity",
+      step: 0.1
+    }
+  },
+  randomSeed: {
+    schema: c.number().int().min(0).max(2147483647).default(42),
+    meta: {
+      label: "Random Seed",
+      description: "Seed for reproducible results",
+      advanced: !0
+    }
+  },
+  maxIterations: {
+    schema: c.number().int().min(1).max(500).default(100),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum refinement iterations",
+      advanced: !0
+    }
+  },
+  threshold: {
+    schema: c.number().min(1e-10).max(0.01).default(1e-6),
+    meta: {
+      label: "Threshold",
+      description: "Convergence threshold",
+      advanced: !0
+    }
+  }
+}, B = class B extends z {
+  /**
+   * Group the nodes into communities, refining each group before it is kept.
+   *
+   * Publishes the community shape's uniform fields: a group per node, and the modularity the
+   * method reported. How many passes it took qualifies those numbers rather than being one of
+   * them, so it travels in the caveats.
+   * @param context - What the element gave the run.
+   * @returns The community result, or null when there are no nodes to group.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    if (t.length === 0)
+      return null;
+    const { resolution: n, randomSeed: a, maxIterations: i, threshold: o } = this.schemaOptions, r = this.algorithmGraph("undirected");
+    e.report({ phase: "Refining communities", total: null });
+    const d = xt(r, {
+      resolution: n,
+      randomSeed: a,
+      maxIterations: i,
+      threshold: o
+    }), h = [];
+    return await N(e, "Grouping nodes", t, (m) => {
+      h.push({ id: m, values: { group: d.communities.get(String(m)) ?? 0 } });
+    }), {
+      shape: "community",
+      fields: _(!0),
+      nodes: h,
+      graph: { modularity: d.modularity },
+      caveats: M({
+        method: "leiden",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "strength" },
+        iterations: d.iterations,
+        notes: [`Resolution ${String(n)}.`]
+      })
+    };
+  }
+};
+B.namespace = "graphty", B.type = "leiden", B.zodOptionsSchema = oa, B.optionsSchema = {
+  resolution: {
+    type: "number",
+    default: 1,
+    label: "Resolution",
+    description: "Controls community granularity",
+    min: 0.1,
+    max: 5,
+    step: 0.1
+  },
+  randomSeed: {
+    type: "integer",
+    default: 42,
+    label: "Random Seed",
+    description: "Seed for reproducible results",
+    min: 0,
+    max: 2147483647,
+    advanced: !0
+  },
+  maxIterations: {
+    type: "integer",
+    default: 100,
+    label: "Max Iterations",
+    description: "Maximum refinement iterations",
+    min: 1,
+    max: 500,
+    advanced: !0
+  },
+  threshold: {
+    type: "number",
+    default: 1e-6,
+    label: "Threshold",
+    description: "Convergence threshold",
+    min: 1e-10,
+    max: 0.01,
+    advanced: !0
+  }
+};
+let Oe = B;
+S.register(Oe);
+const ra = {
+  resolution: {
+    schema: c.number().min(0.1).max(5).default(1),
+    meta: {
+      label: "Resolution",
+      description: "Higher = more communities, lower = fewer larger communities",
+      step: 0.1
+    }
+  },
+  maxIterations: {
+    schema: c.number().int().min(1).max(500).default(100),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum optimization iterations",
+      advanced: !0
+    }
+  },
+  tolerance: {
+    schema: c.number().min(1e-10).max(0.01).default(1e-6),
+    meta: {
+      label: "Tolerance",
+      description: "Minimum modularity improvement to continue",
+      advanced: !0
+    }
+  },
+  useOptimized: {
+    schema: c.boolean().default(!0),
+    meta: {
+      label: "Use Optimized",
+      description: "Use optimized implementation for better performance on large graphs",
+      advanced: !0
+    }
+  }
+}, Y = class Y extends z {
+  /**
+   * Group the nodes into communities by optimising modularity.
+   *
+   * Publishes the community shape's uniform fields: a group per node, and the modularity the
+   * method reported for its own partition. The group sizes, the group count and the size table
+   * are derived from the groups when the result is built, not counted again here.
+   * @param context - What the element gave the run.
+   * @returns The community result, or null when there are no nodes to group.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    if (t.length === 0)
+      return null;
+    const { resolution: n, maxIterations: a, tolerance: i, useOptimized: o } = this.schemaOptions, r = this.algorithmGraph("undirected");
+    e.report({ phase: "Optimizing modularity", total: null });
+    const d = It(r, {
+      resolution: n,
+      maxIterations: a,
+      tolerance: i,
+      useOptimized: o
+    }), h = /* @__PURE__ */ new Map();
+    for (let l = 0; l < d.communities.length; l++)
+      for (const u of d.communities[l])
+        h.set(u, l);
+    const m = [];
+    return await N(e, "Grouping nodes", t, (l) => {
+      m.push({ id: l, values: { group: h.get(l) ?? 0 } });
+    }), {
+      shape: "community",
+      fields: _(!0),
+      nodes: m,
+      graph: { modularity: d.modularity },
+      caveats: M({
+        method: "louvain",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "strength" },
+        notes: [`Resolution ${String(n)}.`]
+      })
+    };
+  }
+};
+Y.namespace = "graphty", Y.type = "louvain", Y.zodOptionsSchema = ra, Y.optionsSchema = {
+  resolution: {
+    type: "number",
+    default: 1,
+    label: "Resolution",
+    description: "Higher = more communities, lower = fewer larger communities",
+    min: 0.1,
+    max: 5,
+    step: 0.1
+  },
+  maxIterations: {
+    type: "integer",
+    default: 100,
+    label: "Max Iterations",
+    description: "Maximum optimization iterations",
+    min: 1,
+    max: 500,
+    advanced: !0
+  },
+  tolerance: {
+    type: "number",
+    default: 1e-6,
+    label: "Tolerance",
+    description: "Minimum modularity improvement to continue",
+    min: 1e-10,
+    max: 0.01,
+    advanced: !0
+  },
+  useOptimized: {
+    type: "boolean",
+    default: !0,
+    label: "Use Optimized",
+    description: "Use optimized implementation for better performance on large graphs",
+    advanced: !0
+  }
+};
+let xe = Y;
+S.register(xe);
+const ca = {
+  source: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Source Node",
+      description: "Source node for flow network (uses first node if not set)"
+    }
+  },
+  sink: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Sink Node",
+      description: "Sink node for flow network (uses last node if not set)"
+    }
+  }
+}, Z = class Z extends z {
+  constructor() {
+    super(...arguments), this.legacyOptions = null;
+  }
+  /**
+   * Configure the algorithm with source and sink nodes
+   * @param options - Configuration options
+   * @param options.source - The source node for the flow network
+   * @param options.sink - The sink node for the flow network
+   * @returns This algorithm instance for chaining
+   * @deprecated Use constructor options instead. This method is kept for backward compatibility.
+   */
+  configure(e) {
+    return this.legacyOptions = e, this;
+  }
+  /**
+   * Find the most that can flow from the source to the sink.
+   *
+   * The answer is a number per edge -- how much runs through it -- so the result is shaped as
+   * an edge metric, and the ranking, the range and the rest come from that column. Two further
+   * numbers travel with each edge because they cannot be recovered from the flow alone: the
+   * capacity it was measured against, and the share of that capacity it used.
+   * @param context - What the element gave the run.
+   * @returns The flow per edge, or null when there is no network to measure.
+   */
+  async compute(e) {
+    const t = this.graph.getDataManager(), n = Array.from(t.edges.values()), a = Array.from(t.nodes.keys());
+    if (n.length === 0 || a.length === 0)
+      return null;
+    const i = this.legacyOptions?.source ?? this._schemaOptions.source, o = this.legacyOptions?.sink ?? this._schemaOptions.sink, r = i === null ? String(a[0]) : re("max-flow", "source", i, a), d = o === null ? String(a[a.length - 1]) : re("max-flow", "sink", o, a), h = new _e({ directed: !0 });
+    for (const y of a)
+      h.addNode(String(y));
+    const m = /* @__PURE__ */ new Map();
+    for (const y of n) {
+      const k = String(y.srcId), I = String(y.dstId), w = y.data, v = y, b = w?.capacity ?? w?.value ?? v.value ?? 1, C = typeof b == "number" ? b : 1;
+      h.addEdge(k, I, C), m.set(T(k, I), C);
+    }
+    e.report({ phase: "Pushing flow", total: null });
+    const l = Mt(h, r, d), u = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map();
+    for (const [y, k] of l.flowGraph)
+      for (const [I, w] of k)
+        p.set(y, (p.get(y) ?? 0) + w), u.set(I, (u.get(I) ?? 0) + w);
+    const f = [];
+    await N(e, "Measuring edges", n, (y) => {
+      const k = String(y.srcId), I = String(y.dstId), w = l.flowGraph.get(k)?.get(I) ?? 0, v = m.get(T(k, I)) ?? 1, b = v > 0 ? Math.abs(w) / v : 0;
+      f.push({ id: y.id, values: { value: w, capacity: v, utilization: b } });
+    });
+    const O = [];
+    return await N(e, "Measuring nodes", a, (y) => {
+      const k = String(y), I = u.get(k) ?? 0, w = p.get(k) ?? 0, v = { netFlow: I - w };
+      k === r ? v.role = "source" : k === d && (v.role = "sink"), O.push({ id: y, values: v });
+    }), {
+      shape: "edge-metric",
+      fields: [
+        ...je("edge"),
+        { name: "capacity", kind: "edge", type: "number" },
+        { name: "utilization", kind: "edge", type: "number" },
+        { name: "netFlow", kind: "node", type: "number" },
+        { name: "role", kind: "node", type: "string" },
+        { name: "maxFlow", kind: "graph", type: "number" }
+      ],
+      nodes: O,
+      edges: f,
+      graph: { maxFlow: l.maxFlow },
+      caveats: M({
+        method: "ford-fulkerson",
+        direction: "directed",
+        weight: { attribute: "capacity", meaning: "strength" },
+        notes: [
+          `Flow from ${r} to ${d}.`,
+          ...i === null || o === null ? [
+            "The source or sink was chosen automatically (the first and last node); set the source and sink options to measure between the nodes you mean."
+          ] : [],
+          ...l.maxFlow === 0 ? [`There is no directed path from ${r} to ${d}, so no flow can run.`] : []
+        ]
+      })
+    };
+  }
+};
+Z.namespace = "graphty", Z.type = "max-flow", Z.zodOptionsSchema = ca, Z.optionsSchema = {
+  source: {
+    type: "nodeId",
+    default: null,
+    label: "Source Node",
+    description: "Source node for flow network (uses first node if not set)",
+    required: !1
+  },
+  sink: {
+    type: "nodeId",
+    default: null,
+    label: "Sink Node",
+    description: "Sink node for flow network (uses last node if not set)",
+    required: !1
+  }
+};
+let Ie = Z;
+S.register(Ie);
+const la = {
+  source: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Source Node",
+      description: "Source node for s-t cut (uses global min cut if not set)"
+    }
+  },
+  sink: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Sink Node",
+      description: "Sink node for s-t cut (uses global min cut if not set)"
+    }
+  },
+  useGlobalMinCut: {
+    schema: c.boolean().default(!1),
+    meta: {
+      label: "Use Global Min Cut",
+      description: "Use global minimum cut algorithm instead of s-t cut"
+    }
+  },
+  useKarger: {
+    schema: c.boolean().default(!1),
+    meta: {
+      label: "Use Karger Algorithm",
+      description: "Use Karger's randomized algorithm instead of Stoer-Wagner for global min cut",
+      advanced: !0
+    }
+  },
+  kargerIterations: {
+    schema: c.number().int().min(1).max(1e4).default(100),
+    meta: {
+      label: "Karger Iterations",
+      description: "Number of iterations for Karger's algorithm (higher = better accuracy but slower)",
+      advanced: !0
+    }
+  }
+}, X = class X extends z {
+  constructor() {
+    super(...arguments), this.legacyOptions = null;
+  }
+  /**
+   * Configure the algorithm with source, sink, and useGlobalMinCut options
+   * @param options - Configuration options
+   * @param options.source - The source node for s-t cut (optional)
+   * @param options.sink - The sink node for s-t cut (optional)
+   * @param options.useGlobalMinCut - Whether to use global min cut (optional)
+   * @returns This algorithm instance for chaining
+   * @deprecated Use constructor options instead. This method is kept for backward compatibility.
+   */
+  configure(e) {
+    return this.legacyOptions = e, this;
+  }
+  /**
+   * Find the cheapest set of edges to remove to split the graph in two.
+   *
+   * A cut is a set of edges, so the result is shaped as one: every edge says whether it is in
+   * the cut, the element counts how many are, and the run publishes what the cut costs, which
+   * is the number the answer is read for. Every node also carries which side of the split it
+   * ended up on, because a cut is only legible beside the two pieces it makes.
+   *
+   * Three methods can answer, and they answer different questions: Stoer-Wagner and Karger find
+   * the cheapest cut anywhere in the graph, while the max-flow route finds the cheapest cut
+   * between two named nodes. Karger is randomised and is the only one that may be wrong, so the
+   * caveats say which ran and whether it was exact.
+   * @param context - What the element gave the run.
+   * @returns The edge set, or null when there is nothing to cut.
+   */
+  async compute(e) {
+    const t = this.graph.getDataManager(), n = Array.from(t.edges.values()), a = Array.from(t.nodes.keys());
+    if (n.length === 0 || a.length === 0)
+      return null;
+    const i = /* @__PURE__ */ new Map(), o = new _e({ directed: !1 });
+    for (const b of a)
+      i.set(String(b), /* @__PURE__ */ new Map()), o.addNode(String(b));
+    for (const b of n) {
+      const C = String(b.srcId), D = String(b.dstId), H = b.data, ae = b, Ve = H?.value ?? ae.value ?? 1, Ke = typeof Ve == "number" ? Ve : 1;
+      i.get(C)?.set(D, Ke), i.get(D)?.set(C, Ke), o.addEdge(C, D, Ke);
+    }
+    const r = this.legacyOptions?.useGlobalMinCut ?? this._schemaOptions.useGlobalMinCut, d = this.legacyOptions?.source ?? this._schemaOptions.source, h = this.legacyOptions?.sink ?? this._schemaOptions.sink, { useKarger: m, kargerIterations: l } = this._schemaOptions;
+    let u, p, f, O, y, k;
+    if (e.report({ phase: "Finding the cut", total: null }), r || d === null && h === null)
+      m ? (y = "karger", { partition1: u, partition2: p, cutEdges: f, cutValue: O } = Ct(i, l)) : (y = "stoer-wagner", { partition1: u, partition2: p, cutEdges: f, cutValue: O } = zt(i));
+    else {
+      y = "min-st-cut";
+      const b = d === null ? String(a[0]) : re("min-cut", "source", d, a), C = h === null ? String(a[a.length - 1]) : re("min-cut", "sink", h, a);
+      (d === null || h === null) && (k = `Only one end was set, so the other was chosen automatically (cut between ${b} and ${C}); set both source and sink to cut between the nodes you mean.`), { partition1: u, partition2: p, cutEdges: f, cutValue: O } = Tt(o, b, C);
+    }
+    const I = /* @__PURE__ */ new Map();
+    for (const b of f)
+      I.set(T(b.from, b.to), b.weight), I.set(T(b.to, b.from), b.weight);
+    const w = [];
+    await N(e, "Marking the cut", n, (b) => {
+      const C = I.get(T(b.srcId, b.dstId));
+      w.push({ id: b.id, values: { in: C !== void 0 } });
+    });
+    const v = [];
+    return await N(e, "Marking the sides", a, (b) => {
+      const C = u.has(String(b));
+      v.push({ id: b, values: { side: C ? "1" : "2" } });
+    }), {
+      shape: "edge-set",
+      fields: [
+        ...We("edge", { name: "cutValue", type: "number" }),
+        { name: "side", kind: "node", type: "string" }
+      ],
+      nodes: v,
+      edges: w,
+      graph: { cutValue: O },
+      caveats: M({
+        method: y,
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "strength" },
+        exact: y !== "karger",
+        iterations: y === "karger" ? l : void 0,
+        notes: [
+          y === "karger" ? "Karger's method is randomised: it finds the cheapest cut with high probability, not certainty." : `The cut separates ${String(u.size)} nodes from ${String(p.size)}.`,
+          ...k === void 0 ? [] : [k]
+        ]
+      })
+    };
+  }
+};
+X.namespace = "graphty", X.type = "min-cut", X.zodOptionsSchema = la, X.optionsSchema = {
+  source: {
+    type: "nodeId",
+    default: null,
+    label: "Source Node",
+    description: "Source node for s-t cut (uses global min cut if not set)",
+    required: !1
+  },
+  sink: {
+    type: "nodeId",
+    default: null,
+    label: "Sink Node",
+    description: "Sink node for s-t cut (uses global min cut if not set)",
+    required: !1
+  },
+  useGlobalMinCut: {
+    type: "boolean",
+    default: !1,
+    label: "Use Global Min Cut",
+    description: "Use global minimum cut algorithm instead of s-t cut",
+    required: !1
+  },
+  useKarger: {
+    type: "boolean",
+    default: !1,
+    label: "Use Karger Algorithm",
+    description: "Use Karger's randomized algorithm instead of Stoer-Wagner for global min cut",
+    advanced: !0
+  },
+  kargerIterations: {
+    type: "integer",
+    default: 100,
+    label: "Karger Iterations",
+    description: "Number of iterations for Karger's algorithm (higher = better accuracy but slower)",
+    min: 1,
+    max: 1e4,
+    advanced: !0
+  }
+};
+let Me = X;
+S.register(Me);
+const Ze = {
+  dampingFactor: {
+    schema: c.number().min(0).max(1).default(0.85),
+    meta: {
+      label: "Damping Factor",
+      description: "Probability of following a link (0.85 is standard for web graphs)",
+      step: 0.05
+    }
+  },
+  maxIterations: {
+    schema: c.number().int().min(1).max(1e3).default(100),
+    meta: {
+      label: "Max Iterations",
+      description: "Maximum power iterations before stopping",
+      advanced: !0
+    }
+  },
+  tolerance: {
+    schema: c.number().min(1e-10).max(0.1).default(1e-6),
+    meta: {
+      label: "Tolerance",
+      description: "Convergence threshold for early stopping",
+      advanced: !0
+    }
+  },
+  weight: {
+    schema: c.string().nullable().default(null),
+    meta: {
+      label: "Weight Attribute",
+      description: "Edge attribute name for weighted PageRank (empty = unweighted)",
+      advanced: !0
+    }
+  },
+  useDelta: {
+    schema: c.boolean().default(!0),
+    meta: {
+      label: "Use Delta Optimization",
+      description: "Use delta-based optimization for faster convergence on large graphs",
+      advanced: !0
+    }
+  }
+}, da = $({
+  plainName: "Influence",
+  technicalName: "PageRank score"
+}), ha = 100;
+function ua(s) {
+  return s.hasPersonalization ? "a personalization vector was given, and only the reference implementation takes one" : s.hasInitialRanks ? "initial ranks were given, and only the reference implementation takes them" : s.directed ? null : "the graph is undirected, and rank flows along out-edges";
+}
+const J = class J extends G {
+  /**
+   * Creates a new PageRank algorithm instance
+   * @param g - The graph to run the algorithm on
+   * @param options - Optional configuration options
+   */
+  constructor(e, t) {
+    super(e, t), this.zodOptions = Ut(Ze, t ?? {}), this.programmaticOptions = {
+      initialRanks: t?.initialRanks ?? null,
+      personalization: t?.personalization ?? null
+    };
+  }
+  /**
+   * The fields a PageRank result publishes.
+   * @returns The uniform node-metric fields.
+   */
+  resultFields() {
+    return da;
+  }
+  /**
+   * Rank every node by the influence flowing into it.
+   * @param context - Where progress goes and where cancellation arrives.
+   * @param nodeIds - The nodes to measure.
+   * @returns One raw rank per node, unscaled.
+   */
+  async measure(e, t) {
+    const { dampingFactor: n, maxIterations: a, tolerance: i, weight: o, useDelta: r } = this.zodOptions, d = this.programmaticOptions.initialRanks ?? void 0, h = this.programmaticOptions.personalization ?? void 0, m = ua({
+      directed: this.graph.getDataManager().getSnapshot().directed,
+      hasInitialRanks: d !== void 0,
+      hasPersonalization: h !== void 0
+    });
+    if (m === null) {
+      const { snapshot: y, run: k } = this.accelerated("pageRank", "directed");
+      e.report({
+        phase: "iterating",
+        completed: 0,
+        total: t.length,
+        message: `Power iteration, up to ${String(a)} passes.`
+      });
+      const { value: I, precision: w } = await k(
+        (D, H) => D.pageRank(H, {
+          dampingFactor: n,
+          maxIterations: a,
+          tolerance: i,
+          // ONE weight column, so naming an attribute is the same request as asking for
+          // a weighted run: the snapshot carries the weight the element resolved.
+          weighted: o !== null
+        })
+      );
+      e.signal.throwIfAborted();
+      const { ids: v } = y, b = [];
+      await F(t, e, "reading ranks", (D) => {
+        const H = v.indexOf(D), ae = H === R ? void 0 : I.scores[H];
+        b.push({ id: D, values: ae === void 0 ? {} : { value: ae } });
+      });
+      const C = [
+        `A reader follows a link with probability ${String(n)} and jumps to a random node otherwise.`,
+        "The ranks sum to 1 across the graph."
+      ];
+      return o === null && C.push("Edge weights are not read."), r && C.push(
+        "Power iteration ran: the delta optimisation is the CPU reference implementation's own and has no index-based counterpart, so it was not taken."
+      ), {
+        nodes: b,
+        normalization: "none",
+        caveats: {
+          exact: !0,
+          direction: "directed",
+          weight: o === null ? null : { attribute: o, meaning: "strength" },
+          precision: w,
+          method: "power-iteration",
+          converged: I.converged,
+          iterations: I.iterations,
+          notes: C
+        }
+      };
+    }
+    const l = this.algorithmGraph("directed"), u = r && l.nodeCount > ha;
+    e.report({
+      phase: "iterating",
+      completed: 0,
+      total: t.length,
+      message: `Power iteration, up to ${String(a)} passes.`
+    });
+    const p = Et(l, {
+      dampingFactor: n,
+      maxIterations: a,
+      tolerance: i,
+      weight: o ?? void 0,
+      useDelta: r,
+      initialRanks: d,
+      personalization: h
+    });
+    e.signal.throwIfAborted();
+    const f = [];
+    await F(t, e, "reading ranks", (y) => {
+      const k = p.ranks[String(y)];
+      f.push({ id: y, values: k === void 0 ? {} : { value: k } });
+    });
+    const O = [
+      `A reader follows a link with probability ${String(n)} and jumps to a random node otherwise.`,
+      "The ranks sum to 1 across the graph.",
+      `Computed on the CPU reference implementation: ${m}.`
+    ];
+    return u && O.push(
+      "The delta method ran, and it reports neither how many passes it took nor whether it converged, so this run cannot say."
+    ), o === null && O.push("Edge weights are not read."), {
+      nodes: f,
+      // Raw ranks, published as they were computed.
+      normalization: "none",
+      caveats: {
+        exact: !0,
+        direction: "directed",
+        weight: o === null ? null : { attribute: o, meaning: "strength" },
+        precision: "f64",
+        method: u ? "delta-pagerank" : "power-iteration",
+        // Present only when the method that ran measured them. Absent is the honest
+        // answer where it did not; a hard-coded `true` was the defect this replaces.
+        ...u ? {} : { converged: p.converged, iterations: p.iterations },
+        notes: O
+      }
+    };
+  }
+};
+J.namespace = "graphty", J.type = "pagerank", J.zodOptionsSchema = Ze, J.optionsSchema = {
+  dampingFactor: {
+    type: "number",
+    default: 0.85,
+    label: "Damping Factor",
+    description: "Probability of following a link (0.85 is standard for web graphs)",
+    min: 0,
+    max: 1,
+    step: 0.05
+  },
+  maxIterations: {
+    type: "integer",
+    default: 100,
+    label: "Max Iterations",
+    description: "Maximum power iterations before stopping",
+    min: 1,
+    max: 1e3,
+    advanced: !0
+  },
+  tolerance: {
+    type: "number",
+    default: 1e-6,
+    label: "Tolerance",
+    description: "Convergence threshold for early stopping",
+    min: 1e-10,
+    max: 0.1,
+    advanced: !0
+  },
+  weight: {
+    type: "string",
+    default: null,
+    label: "Weight Attribute",
+    description: "Edge attribute name for weighted PageRank (empty = unweighted)",
+    advanced: !0
+  },
+  useDelta: {
+    type: "boolean",
+    default: !0,
+    label: "Use Delta Optimization",
+    description: "Use delta-based optimization for faster convergence on large graphs",
+    advanced: !0
+  }
+  // Note: initialRanks and personalization are Map types - programmatic only, not in schema
+};
+let Ce = J;
+S.register(Ce);
+const pa = {
+  startNode: {
+    schema: c.union([c.string(), c.number()]).nullable().default(null),
+    meta: {
+      label: "Start Node",
+      description: "Starting node for MST growth (uses first node if not set)"
+    }
+  }
+}, Q = class Q extends z {
+  constructor() {
+    super(...arguments), this.legacyOptions = null;
+  }
+  /**
+   * Configure the algorithm with an optional start node
+   * @param options - Configuration options
+   * @param options.startNode - The optional start node ID
+   * @returns This algorithm instance for chaining
+   * @deprecated Use constructor options instead. This method is kept for backward compatibility.
+   */
+  configure(e) {
+    return this.legacyOptions = { startNode: e.startNode ?? null }, this;
+  }
+  /**
+   * Find the cheapest set of edges that still joins every node.
+   *
+   * A spanning tree is a set of edges, so the result is shaped as one: every edge says whether
+   * it is in the network, the element counts how many are, and the run publishes the one number
+   * the answer is actually read for -- what the network costs in total.
+   * @param context - What the element gave the run.
+   * @returns The edge set, or null when there are no edges to choose from.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().edges.values());
+    if (t.length === 0)
+      return null;
+    const n = this.legacyOptions?.startNode ?? this._schemaOptions.startNode ?? void 0, a = this.algorithmGraph("undirected");
+    e.report({ phase: "Choosing edges", total: null });
+    const i = Dt(a, n), o = /* @__PURE__ */ new Set();
+    for (const d of i.edges)
+      o.add(T(d.source, d.target)), o.add(T(d.target, d.source));
+    const r = [];
+    return await N(e, "Marking the network", t, (d) => {
+      r.push({ id: d.id, values: { in: o.has(T(d.srcId, d.dstId)) } });
+    }), {
+      shape: "edge-set",
+      fields: We("edge", { name: "totalWeight", type: "number" }),
+      edges: r,
+      graph: { totalWeight: i.totalWeight },
+      caveats: M({
+        method: "prim",
+        direction: "undirected",
+        weight: { attribute: "weight", meaning: "distance" },
+        notes: [`The tree joins the graph with ${String(i.edges.length)} edges.`]
+      })
+    };
+  }
+};
+Q.namespace = "graphty", Q.type = "prim", Q.zodOptionsSchema = pa, Q.optionsSchema = {
+  startNode: {
+    type: "nodeId",
+    default: null,
+    label: "Start Node",
+    description: "Starting node for MST growth (uses first node if not set)",
+    required: !1
+  }
+};
+let ze = Q;
+S.register(ze);
+const He = class He extends z {
+  /**
+   * Find the pieces of the graph that a directed path can cross both ways.
+   *
+   * The same community shape as the weak reading, run at the other strength: two nodes share a
+   * group only when a directed path runs each way between them. The caveats say which strength
+   * ran, because on a directed graph the two answers differ and the numbers do not say so.
+   * @param context - What the element gave the run.
+   * @returns The community result, or null when there are no nodes to group.
+   */
+  async compute(e) {
+    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    if (t.length === 0)
+      return null;
+    const n = this.algorithmGraph("directed");
+    e.report({ phase: "Finding pieces", total: null });
+    const a = Pt(n), i = /* @__PURE__ */ new Map();
+    for (let r = 0; r < a.length; r++)
+      for (const d of a[r])
+        i.set(d, r);
+    const o = [];
+    return await N(e, "Grouping nodes", t, (r) => {
+      o.push({ id: r, values: { group: i.get(r) ?? 0 } });
+    }), {
+      shape: "community",
+      fields: _(!1),
+      nodes: o,
+      caveats: M({
+        method: "strongly-connected-components",
+        direction: "directed",
+        weight: null,
+        notes: ["Strength: strong. Two nodes share a piece only when a directed path runs each way."]
+      })
+    };
+  }
+};
+He.namespace = "graphty", He.type = "scc";
+let Te = He;
+S.register(Te);
+const ma = "results.$";
+function g(s) {
+  return { ...s, path: `${ma}.${s.name}` };
+}
+function E(s, e) {
+  return [
+    g({
+      name: "value",
+      plainName: e.plainName,
+      technicalName: e.technicalName,
+      kind: s,
+      type: e.type ?? "number",
+      ...e.unit === void 0 ? {} : { unit: e.unit }
+    }),
+    g({ name: "rank", plainName: "Rank", technicalName: "rank", kind: s, type: "integer" }),
+    g({ name: "percentile", plainName: "Percentile", technicalName: "percentile", kind: s, type: "number" }),
+    g({ name: "min", plainName: "Lowest", technicalName: "min", kind: "graph", type: "number" }),
+    g({ name: "max", plainName: "Highest", technicalName: "max", kind: "graph", type: "number" }),
+    g({ name: "median", plainName: "Middle", technicalName: "median", kind: "graph", type: "number" }),
+    g({ name: "mean", plainName: "Average", technicalName: "mean", kind: "graph", type: "number" }),
+    g({ name: "measured", plainName: "Measured", technicalName: "measured", kind: "graph", type: "integer" }),
+    g({
+      name: "normalization",
+      plainName: "Normalization",
+      technicalName: "normalization",
+      kind: "graph",
+      type: "string"
+    }),
+    g({
+      name: "tiedAtMin",
+      plainName: "Tied at the lowest value",
+      technicalName: "tiedAtMin",
+      kind: "graph",
+      type: "integer"
+    })
+  ];
+}
+function ee(s, e) {
+  const t = [
+    g({ name: "group", plainName: s, technicalName: "group", kind: "node", type: "integer" }),
+    g({
+      name: "groupSize",
+      plainName: `${s} size`,
+      technicalName: "groupSize",
+      kind: "node",
+      type: "integer"
+    }),
+    g({
+      name: "groupCount",
+      plainName: `${s} count`,
+      technicalName: "groupCount",
+      kind: "graph",
+      type: "integer"
+    }),
+    g({
+      name: "sizes",
+      plainName: `${s} sizes`,
+      technicalName: "sizes",
+      kind: "graph",
+      type: "table"
+    })
+  ];
+  return e && t.push(
+    g({
+      name: "modularity",
+      plainName: "Community strength",
+      technicalName: "modularity",
+      kind: "graph",
+      type: "number"
+    })
+  ), t;
+}
+function se(s, e, t) {
+  return [
+    g({ name: "in", plainName: e, technicalName: "in", kind: s, type: "boolean" }),
+    g({ name: "count", plainName: "Count", technicalName: "count", kind: "graph", type: "integer" }),
+    g({ ...t, kind: "graph" })
+  ];
+}
+function x(s) {
+  return Ue(s.getZodOptionsSchema());
+}
+function Xe(...s) {
+  const e = [], t = /* @__PURE__ */ new Set();
+  for (const n of s)
+    for (const a of n)
+      t.has(a.name) || (t.add(a.name), e.push(a));
+  return e;
+}
+const ga = {
+  method: {
+    schema: c.enum(["dijkstra", "bellman-ford"]).nullable().default(null),
+    meta: {
+      label: "Method",
+      description: "Which engine computes the paths. Left unset, the element uses Dijkstra when every weight is zero or above and Bellman-Ford when any weight is negative.",
+      advanced: !0,
+      group: "engine"
+    }
+  }
+}, fa = {
+  strength: {
+    schema: c.enum(["weak", "strong"]).default("weak"),
+    meta: {
+      label: "Strength",
+      description: "Weak follows an edge in either direction. Strong needs a directed path each way, and only differs from weak on a directed graph."
+    }
+  }
+}, nt = [
+  {
+    key: "degree",
+    plainName: "Connections",
+    technicalName: "Degree centrality",
+    description: "Counts how many edges each node has, incoming, outgoing and in total.",
+    category: "centrality",
+    shape: "node-metric",
+    fields: [
+      ...E("node", { plainName: "Connections", technicalName: "degree", type: "integer", unit: "links" }),
+      g({
+        name: "inDegree",
+        plainName: "Incoming connections",
+        technicalName: "inDegree",
+        kind: "node",
+        type: "integer"
+      }),
+      g({
+        name: "outDegree",
+        plainName: "Outgoing connections",
+        technicalName: "outDegree",
+        kind: "node",
+        type: "integer"
+      })
+    ],
+    options: x(me),
+    costClass: "instant",
+    complexity: "O(n + m)",
+    legacyKeys: [{ key: "degree" }]
+  },
+  {
+    key: "betweenness",
+    plainName: "Bridges",
+    technicalName: "Betweenness centrality",
+    description: "Scores a node by how many of the shortest paths between other nodes run through it, which is what finds the bridges.",
+    category: "centrality",
+    shape: "node-metric",
+    fields: E("node", { plainName: "Bridging", technicalName: "betweenness" }),
+    options: x(le),
+    costClass: "heavy",
+    complexity: "O(n * m)",
+    legacyKeys: [{ key: "betweenness" }]
+  },
+  {
+    key: "closeness",
+    plainName: "Reach",
+    technicalName: "Closeness centrality",
+    description: "Scores a node by how short its paths to the rest of the graph are, which is what finds the nodes that reach everything quickly.",
+    category: "centrality",
+    shape: "node-metric",
+    fields: E("node", { plainName: "Reach", technicalName: "closeness" }),
+    options: x(ue),
+    costClass: "heavy",
+    complexity: "O(n * m)",
+    legacyKeys: [{ key: "closeness" }]
+  },
+  {
+    key: "pagerank",
+    plainName: "Influence",
+    technicalName: "PageRank",
+    description: "Ranks a node by the influence that flows into it from the nodes that point at it.",
+    category: "centrality",
+    shape: "node-metric",
+    fields: E("node", { plainName: "Influence", technicalName: "PageRank score" }),
+    options: x(Ce),
+    costClass: "iterative",
+    complexity: "O(k(n + m))",
+    legacyKeys: [{ key: "pagerank" }]
+  },
+  {
+    key: "eigenvector",
+    plainName: "Influence by association",
+    technicalName: "Eigenvector centrality",
+    description: "Scores a node by how influential its neighbours are, so a few important connections count for more than many unimportant ones.",
+    category: "centrality",
+    shape: "node-metric",
+    fields: E("node", { plainName: "Influence by association", technicalName: "eigenvector score" }),
+    options: x(ye),
+    costClass: "iterative",
+    complexity: "O(k(n + m))",
+    legacyKeys: [{ key: "eigenvector" }]
+  },
+  {
+    key: "katz",
+    plainName: "Influence at a distance",
+    technicalName: "Katz centrality",
+    description: "Scores a node by every path that reaches it, with a longer path counting for less.",
+    category: "centrality",
+    shape: "node-metric",
+    fields: E("node", { plainName: "Influence at a distance", technicalName: "Katz score" }),
+    options: x(Ne),
+    costClass: "iterative",
+    complexity: "O(k(n + m))",
+    legacyKeys: [{ key: "katz" }]
+  },
+  {
+    key: "hits",
+    plainName: "Hubs and authorities",
+    technicalName: "HITS",
+    description: "Scores every node twice: as a hub that points at good sources, and as an authority that good hubs point at.",
+    category: "centrality",
+    shape: "node-metric",
+    fields: [
+      ...E("node", { plainName: "Hub and authority", technicalName: "combined HITS score" }),
+      g({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
+      g({
+        name: "authority",
+        plainName: "Authority",
+        technicalName: "authority score",
+        kind: "node",
+        type: "number"
+      })
+    ],
+    options: x(ve),
+    costClass: "iterative",
+    complexity: "O(k(n + m))",
+    legacyKeys: [{ key: "hits" }]
+  },
+  {
+    key: "louvain",
+    plainName: "Communities",
+    technicalName: "Louvain",
+    description: "Groups nodes into communities by repeatedly merging the groups whose merger tightens the partition the most.",
+    category: "community",
+    shape: "community",
+    fields: ee("Community", !0),
+    options: x(xe),
+    costClass: "iterative",
+    complexity: "O(k(n + m))",
+    legacyKeys: [{ key: "louvain" }]
+  },
+  {
+    key: "leiden",
+    plainName: "Communities, refined",
+    technicalName: "Leiden",
+    description: "Groups nodes into communities the way Louvain does, with a refinement pass that rules out groups held together by a single node.",
+    category: "community",
+    shape: "community",
+    fields: ee("Community", !0),
+    options: x(Oe),
+    costClass: "iterative",
+    complexity: "O(k(n + m))",
+    legacyKeys: [{ key: "leiden" }]
+  },
+  {
+    key: "label-propagation",
+    plainName: "Communities, fast",
+    technicalName: "Label propagation",
+    description: "Groups nodes into communities by letting every node repeatedly take whichever label most of its neighbours carry.",
+    category: "community",
+    shape: "community",
+    fields: ee("Community", !1),
+    options: x(Se),
+    costClass: "iterative",
+    complexity: "O(k(n + m))",
+    legacyKeys: [{ key: "label-propagation" }]
+  },
+  {
+    key: "girvan-newman",
+    plainName: "Communities by cutting bridges",
+    technicalName: "Girvan-Newman",
+    description: "Groups nodes into communities by repeatedly cutting the edge that the most shortest paths run through, until the graph falls apart.",
+    category: "community",
+    shape: "community",
+    fields: ee("Community", !0),
+    options: x(we),
+    costClass: "heavy",
+    complexity: "O(n * m^2)",
+    legacyKeys: [{ key: "girvan-newman" }]
+  },
+  {
+    key: "components",
+    plainName: "Separate pieces",
+    technicalName: "Connected components",
+    description: "Finds the separate pieces of the graph: two nodes belong to the same piece when a path joins them.",
+    category: "structure",
+    shape: "community",
+    fields: ee("Piece", !1),
+    options: Xe(
+      x(pe),
+      x(Te),
+      Ue(fa)
+    ),
+    costClass: "instant",
+    complexity: "O(n + m)",
+    legacyKeys: [{ key: "connected-components" }, { key: "scc", params: { strength: "strong" } }]
+  },
+  {
+    key: "shortest-path",
+    plainName: "Shortest route",
+    technicalName: "Shortest path",
+    description: "Finds the cheapest route from one node to another, and how far every reachable node is from the source.",
+    category: "path",
+    shape: "path",
+    fields: [
+      g({ name: "onPath", plainName: "On the route", technicalName: "onPath", kind: "node", type: "boolean" }),
+      g({ name: "order", plainName: "Position on the route", technicalName: "order", kind: "node", type: "integer" }),
+      g({ name: "distance", plainName: "Distance from the source", technicalName: "distance", kind: "node", type: "number" }),
+      g({ name: "onPath", plainName: "On the route", technicalName: "onPath", kind: "edge", type: "boolean" }),
+      g({ name: "length", plainName: "Nodes on the route", technicalName: "length", kind: "graph", type: "integer" }),
+      g({ name: "cost", plainName: "Total cost", technicalName: "cost", kind: "graph", type: "number" }),
+      g({ name: "hops", plainName: "Edges on the route", technicalName: "hops", kind: "graph", type: "integer" }),
+      g({
+        name: "hasNegativeCycle",
+        plainName: "Has a loop that costs less every time round",
+        technicalName: "hasNegativeCycle",
+        kind: "graph",
+        type: "boolean"
+      })
+    ],
+    options: Xe(
+      x(fe),
+      x(ce),
+      Ue(ga)
+    ),
+    costClass: "instant",
+    complexity: "O((n + m) log n) with dijkstra, O(n * m) with bellman-ford",
+    legacyKeys: [
+      { key: "dijkstra", params: { method: "dijkstra" } },
+      { key: "bellman-ford", params: { method: "bellman-ford" } }
+    ]
+  },
+  {
+    /* ONE KEY, ONE RESULT SHAPE. The all-pairs sweep used to be a PARAMETER on shortest-path
+       -- `allPairs: true`, engine floyd-warshall -- which made one catalogue key claim two
+       different result shapes: a route for the single-source engines, and a measurement of
+       every node for this one. A run takes its shape from its descriptor once, at creation,
+       so the all-pairs run reported "path", found no `onPath` to paint from, and suggested
+       nothing; `styles.encode` refused a hand-written encoding for the same reason. Its own
+       key is what makes the shape true, and every consumer that reads the catalogue up front
+       right about what a run of it will publish. */
+    key: "all-pairs-distance",
+    plainName: "How far from everything else",
+    technicalName: "All-pairs shortest paths",
+    description: "Measures the distance between every pair of nodes, and gives each node the distance to the furthest node it can reach.",
+    category: "path",
+    shape: "node-metric",
+    fields: [
+      ...E("node", { plainName: "Distance to the furthest node", technicalName: "eccentricity" }),
+      g({ name: "diameter", plainName: "Widest distance", technicalName: "diameter", kind: "graph", type: "number" }),
+      g({ name: "radius", plainName: "Narrowest distance", technicalName: "radius", kind: "graph", type: "number" }),
+      g({
+        name: "hasNegativeCycle",
+        plainName: "Has a loop that costs less every time round",
+        technicalName: "hasNegativeCycle",
+        kind: "graph",
+        type: "boolean"
+      })
+    ],
+    options: x(be),
+    costClass: "cubic",
+    complexity: "O(n^3)",
+    legacyKeys: [{ key: "floyd-warshall" }]
+  },
+  {
+    key: "bfs",
+    plainName: "Steps away",
+    technicalName: "Breadth-first search",
+    description: "Walks outwards from one node a level at a time, recording how many steps away each node is.",
+    category: "path",
+    shape: "layered-grouping",
+    fields: [
+      g({ name: "level", plainName: "Steps away", technicalName: "level", kind: "node", type: "integer" }),
+      g({ name: "levelSize", plainName: "Nodes this many steps away", technicalName: "levelSize", kind: "node", type: "integer" }),
+      g({ name: "order", plainName: "Visit order", technicalName: "order", kind: "node", type: "integer" }),
+      g({ name: "levelCount", plainName: "Levels", technicalName: "levelCount", kind: "graph", type: "integer" }),
+      g({ name: "sizes", plainName: "Level sizes", technicalName: "sizes", kind: "graph", type: "table" }),
+      g({ name: "targetFound", plainName: "Target reached", technicalName: "targetFound", kind: "graph", type: "boolean" })
+    ],
+    options: x(de),
+    costClass: "instant",
+    complexity: "O(n + m)",
+    legacyKeys: [{ key: "bfs" }]
+  },
+  {
+    key: "dfs",
+    plainName: "Exploration order",
+    technicalName: "Depth-first search",
+    description: "Walks as deep as it can from one node before backtracking, recording the order in which it reached each node.",
+    category: "path",
+    shape: "node-metric",
+    fields: [
+      ...E("node", { plainName: "Exploration order", technicalName: "discovery time", type: "integer" }),
+      g({ name: "visited", plainName: "Reached", technicalName: "visited", kind: "node", type: "boolean" })
+    ],
+    options: x(ge),
+    costClass: "instant",
+    complexity: "O(n + m)",
+    legacyKeys: [{ key: "dfs" }]
+  },
+  {
+    key: "kruskal",
+    plainName: "Cheapest connecting network",
+    technicalName: "Kruskal minimum spanning tree",
+    description: "Finds the cheapest set of edges that still joins every node, by taking the cheapest edge that does not close a loop.",
+    category: "structure",
+    shape: "edge-set",
+    fields: se("edge", "In the network", {
+      name: "totalWeight",
+      plainName: "Total cost",
+      technicalName: "totalWeight",
+      type: "number"
+    }),
+    options: x(ke),
+    costClass: "instant",
+    complexity: "O(m log m)",
+    requires: { directed: !1 },
+    legacyKeys: [{ key: "kruskal" }]
+  },
+  {
+    key: "prim",
+    plainName: "Cheapest network from one node",
+    technicalName: "Prim minimum spanning tree",
+    description: "Finds the cheapest set of edges that still joins every node, by growing outwards from one starting node.",
+    category: "structure",
+    shape: "edge-set",
+    fields: se("edge", "In the network", {
+      name: "totalWeight",
+      plainName: "Total cost",
+      technicalName: "totalWeight",
+      type: "number"
+    }),
+    options: x(ze),
+    costClass: "instant",
+    complexity: "O(m log n)",
+    requires: { directed: !1 },
+    legacyKeys: [{ key: "prim" }]
+  },
+  {
+    key: "bipartite-matching",
+    plainName: "Best pairing",
+    technicalName: "Maximum bipartite matching",
+    description: "Pairs up the two sides of a two-sided graph so that as many nodes as possible end up with a partner.",
+    category: "structure",
+    shape: "edge-set",
+    fields: [
+      ...se("edge", "In the pairing", {
+        name: "bipartite",
+        plainName: "Has two sides",
+        technicalName: "bipartite",
+        type: "boolean"
+      }),
+      g({ name: "side", plainName: "Side", technicalName: "side", kind: "node", type: "string" }),
+      g({ name: "matched", plainName: "Paired", technicalName: "matched", kind: "node", type: "boolean" })
+    ],
+    options: x(he),
+    costClass: "heavy",
+    complexity: "O(n * m)",
+    requires: { directed: !1 },
+    legacyKeys: [{ key: "bipartite-matching" }]
+  },
+  {
+    key: "max-flow",
+    plainName: "Most that can flow",
+    technicalName: "Maximum flow",
+    description: "Finds the most that can flow from a source to a sink when every edge has a capacity.",
+    category: "flow",
+    shape: "edge-metric",
+    fields: [
+      ...E("edge", { plainName: "Flow", technicalName: "flow" }),
+      g({ name: "capacity", plainName: "Capacity", technicalName: "capacity", kind: "edge", type: "number" }),
+      g({ name: "utilization", plainName: "Share of capacity used", technicalName: "utilization", kind: "edge", type: "number" }),
+      g({ name: "netFlow", plainName: "Net flow", technicalName: "netFlow", kind: "node", type: "number" }),
+      g({ name: "role", plainName: "Source or sink", technicalName: "role", kind: "node", type: "string" }),
+      g({ name: "maxFlow", plainName: "Most that can flow", technicalName: "maxFlow", kind: "graph", type: "number" })
+    ],
+    options: x(Ie),
+    costClass: "heavy",
+    complexity: "O(n * m^2)",
+    legacyKeys: [{ key: "max-flow" }]
+  },
+  {
+    key: "min-cut",
+    plainName: "Weakest link",
+    technicalName: "Minimum cut",
+    description: "Finds the cheapest set of edges to remove to split the graph into two pieces.",
+    category: "flow",
+    shape: "edge-set",
+    fields: [
+      ...se("edge", "In the cut", {
+        name: "cutValue",
+        plainName: "Cost of the cut",
+        technicalName: "cutValue",
+        type: "number"
+      }),
+      g({ name: "side", plainName: "Side", technicalName: "side", kind: "node", type: "string" })
+    ],
+    options: x(Me),
+    costClass: "heavy",
+    complexity: "O(n * m^2) between two nodes, O(n * m + n^2 log n) across the whole graph, O(k * n^2) with Karger",
+    legacyKeys: [{ key: "min-cut" }]
+  }
+];
+function Da(s) {
+  return nt.find((e) => e.key === s);
+}
+function Pa(s) {
+  for (const e of nt)
+    for (const t of e.legacyKeys)
+      if (t.key === s)
+        return { descriptor: e, params: t.params ?? {} };
+}
+export {
+  Me as A,
+  nt as B,
+  at as C,
+  me as D,
+  ye as E,
+  be as F,
+  we as G,
+  ve as H,
+  Lt as I,
+  Ne as K,
+  xe as L,
+  Ie as M,
+  Wt as N,
+  Ce as P,
+  Te as S,
+  tt as a,
+  te as b,
+  Da as c,
+  Pa as d,
+  za as e,
+  Ta as f,
+  Ma as g,
+  Ca as h,
+  Oa as i,
+  xa as j,
+  Ea as k,
+  Kt as l,
+  Ia as m,
+  fe as n,
+  le as o,
+  ue as p,
+  Oe as q,
+  Se as r,
+  ce as s,
+  $t as t,
+  de as u,
+  ge as v,
+  pe as w,
+  ke as x,
+  ze as y,
+  he as z
+};