@graphty/graphty-element 2.3.1 → 2.4.0

package/dist/chunks/{algorithms-CpX56sUB.js → algorithms-BF0X6RPw.js}

@@ -1,27 +1,27 @@
-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 { c as rt } from "./common-DWNKjpH_.js";
+import { E as ct, a as lt, N as dt } from "./NodeStyle-CtmA7dXi.js";
+import { F as ht, k as ut, a as z, h as S, P as tt, f as M, A as v, Y as pt, G as mt, H as gt, n as $, L as Ze, s as je, e as ee, m as re, i as Be, o as Ae } from "./optionsFromZod-BuTOFgVM.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;
+import { bellmanFord as ft, betweennessCentrality as yt, breadthFirstSearch as bt, bipartitePartition as wt, maximumBipartiteMatching as vt, closenessCentrality as Nt, depthFirstSearch as kt, eigenvectorCentrality as St, ConvergenceError as Ot, floydWarshall as xt, girvanNewman as It, hits as Mt, katzCentrality as Ct, kCoreDecomposition as zt, labelPropagation as Tt, leiden as Et, commonNeighborsPrediction as Dt, adamicAdarPrediction as Pt, louvain as Rt, Graph as at, fordFulkerson as Ft, kargerMinCut as $t, stoerWagner as Gt, minSTCut as Ht, pageRank as Wt, primMST as Kt, stronglyConnectedComponents as Lt } from "@graphty/algorithms";
+import { G as nt } from "./GraphtyError-B93WRH3e.js";
+import { INVALID_INDEX as F } from "@graphty/graph-format";
+var Fa = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function $a(o) {
+  return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, "default") ? o.default : o;
 }
-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;
+const Ut = /^#?(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i;
+function qe(o) {
+  return Number.isFinite(o) ? Math.max(0, Math.min(255, Math.round(o))) : 0;
 }
-function ne(s) {
-  return s.toString(16).padStart(2, "0");
+function ie(o) {
+  return o.toString(16).padStart(2, "0");
 }
-function Ft(s) {
-  if (!Rt.test(s))
+function jt(o) {
+  if (!Ut.test(o))
     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);
+  const e = o.startsWith("#") ? o.slice(1) : o, t = e.length <= 4, n = (i) => {
+    const s = t ? e[i].repeat(2) : e.slice(i * 2, i * 2 + 2);
+    return parseInt(s, 16);
   }, a = e.length === 4 || e.length === 8;
   return {
     r: n(0),
@@ -30,29 +30,29 @@ function Ft(s) {
     a: a ? n(3) / 255 : 1
   };
 }
-function Ia(s) {
-  return typeof s != "object" || s === null || !("hex" in s) ? null : s;
+function Ga(o) {
+  return typeof o != "object" || o === null || !("hex" in o) ? null : o;
 }
-function $t(s) {
-  if (s == null)
+function Vt(o) {
+  if (o == null)
     return null;
-  if (typeof s == "object")
-    return Ae(s);
-  const e = Ft(s);
+  if (typeof o == "object")
+    return Xe(o);
+  const e = jt(o);
   if (e !== null)
-    return Ae(e);
+    return Xe(e);
   try {
-    const t = it(s);
-    return t === void 0 ? null : $t(t);
+    const t = rt(o);
+    return t === void 0 ? null : Vt(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))}` };
+function Xe(o) {
+  const e = qe(o.r), t = qe(o.g), n = qe(o.b), a = Number.isFinite(o.a) ? Math.max(0, Math.min(1, o.a)) : 1, i = `#${ie(e)}${ie(t)}${ie(n)}`;
+  return { r: e, g: t, b: n, a, hex: a === 1 ? i : `${i}${ie(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 = {
+const qt = dt.options, At = lt.options, Je = ct.options, Bt = "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.", se = '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`.', Qe = "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.", ae = {
   "node.color": {
     channel: "node.color",
     target: "node",
@@ -75,7 +75,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     target: "node",
     plainName: "Node Shape",
     accepts: "enum",
-    values: Gt,
+    values: qt,
     stylePath: "shape.type",
     renderable: !0
   },
@@ -102,7 +102,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     accepts: "text",
     stylePath: "tooltip.text",
     renderable: !0,
-    caveat: Ye
+    caveat: Qe
   },
   "node.tooltipStyle": {
     channel: "node.tooltipStyle",
@@ -111,7 +111,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     accepts: "labelStyle",
     stylePath: "tooltip",
     renderable: !0,
-    caveat: Ye
+    caveat: Qe
   },
   "node.opacity": {
     channel: "node.opacity",
@@ -130,7 +130,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     accepts: "color",
     stylePath: "effect.outline.color",
     renderable: !0,
-    caveat: Wt
+    caveat: Bt
   },
   "node.glow": {
     channel: "node.glow",
@@ -206,7 +206,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     target: "edge",
     plainName: "Edge Line Pattern",
     accepts: "enum",
-    values: Ht,
+    values: At,
     stylePath: "line.type",
     renderable: !0
   },
@@ -234,7 +234,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     target: "edge",
     plainName: "Arrow Head",
     accepts: "enum",
-    values: Be,
+    values: Je,
     stylePath: "arrowHead.type",
     renderable: !0
   },
@@ -272,7 +272,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     accepts: "text",
     stylePath: "arrowHead.text.text",
     renderable: !0,
-    caveat: ie
+    caveat: se
   },
   "edge.arrowHeadTextStyle": {
     channel: "edge.arrowHeadTextStyle",
@@ -281,14 +281,14 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     accepts: "labelStyle",
     stylePath: "arrowHead.text",
     renderable: !0,
-    caveat: ie
+    caveat: se
   },
   "edge.arrowTail": {
     channel: "edge.arrowTail",
     target: "edge",
     plainName: "Arrow Tail",
     accepts: "enum",
-    values: Be,
+    values: Je,
     stylePath: "arrowTail.type",
     renderable: !0
   },
@@ -326,7 +326,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     accepts: "text",
     stylePath: "arrowTail.text.text",
     renderable: !0,
-    caveat: ie
+    caveat: se
   },
   "edge.arrowTailTextStyle": {
     channel: "edge.arrowTailTextStyle",
@@ -335,7 +335,7 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     accepts: "labelStyle",
     stylePath: "arrowTail.text",
     renderable: !0,
-    caveat: ie
+    caveat: se
   },
   "edge.animationSpeed": {
     channel: "edge.animationSpeed",
@@ -362,22 +362,22 @@ const Gt = st.options, Ht = Je.shape.line.unwrap().shape.type.unwrap().options,
     stylePath: "label",
     renderable: !0
   }
-}, tt = Object.keys(te);
-tt.filter(
-  (s) => te[s].accepts === "color"
+}, it = Object.keys(ae);
+it.filter(
+  (o) => ae[o].accepts === "color"
 );
-function Kt(s) {
-  return typeof s == "string" && Object.hasOwn(te, s);
+function Yt(o) {
+  return typeof o == "string" && Object.hasOwn(ae, o);
 }
-function Ma(s) {
-  return Kt(s) ? te[s] : void 0;
+function Ha(o) {
+  return Yt(o) ? ae[o] : void 0;
 }
-function Ca(s) {
-  return tt.map((e) => te[e]).filter(
-    (e) => e.target === s
+function Wa(o) {
+  return it.map((e) => ae[e]).filter(
+    (e) => e.target === o
   );
 }
-const at = Object.freeze([
+const st = Object.freeze([
   {
     id: "fitToGraph",
     plainName: "Fit to graph",
@@ -414,41 +414,41 @@ const at = Object.freeze([
     options: []
   }
 ]);
-function za(s) {
-  return at.find((e) => e.id === s) ?? ot(s)?.descriptor;
+function Ka(o) {
+  return st.find((e) => e.id === o) ?? ht(o)?.descriptor;
 }
-function Ta(s) {
-  return [...at, ...rt()].filter(
-    (e) => e.modes.includes(s)
+function La(o) {
+  return [...st, ...ut()].filter(
+    (e) => e.modes.includes(o)
   );
 }
-function Ea(s) {
-  return s;
+function Ua(o) {
+  return o;
 }
-function Lt(s) {
+function Zt(o) {
   const e = {};
-  for (const [t, n] of Object.entries(s))
+  for (const [t, n] of Object.entries(o))
     e[t] = n.schema;
   return c.object(e);
 }
-function Ut(s, e) {
-  return Lt(s).parse(e);
+function Xt(o, e) {
+  return Zt(o).parse(e);
 }
-function T(s, e) {
-  return `${String(s)}:${String(e)}`;
+function T(o, e) {
+  return `${String(o)}:${String(e)}`;
 }
-function re(s, e, t, n) {
+function ce(o, e, t, n) {
   const a = String(t);
   if (!n.some((i) => String(i) === a))
-    throw new et({
+    throw new nt({
       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 }
+      message: `${o}: the ${e} option names node "${a}", which is not in the graph.`,
+      details: { algorithm: o, option: e, value: t }
     });
   return a;
 }
-const jt = {
+const Jt = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -492,43 +492,43 @@ const jt = {
     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");
+    const a = this.legacyOptions?.source ?? this._schemaOptions.source ?? n[0], i = this.legacyOptions?.target ?? this._schemaOptions.target ?? n[n.length - 1], s = 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 r = ft(s, a), l = this.reconstructPath(r.predecessors, a, i), h = /* @__PURE__ */ new Map();
+    l.forEach((g, x) => h.set(g, x));
+    for (const g 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 } });
+    await S(e, "Marking the route", n, (g) => {
+      const x = h.get(g), y = r.distances.get(g) ?? 1 / 0;
+      m.push({ id: g, values: { onPath: x !== void 0, order: x, 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 d = this.getPathEdges(l), p = [];
+    await S(e, "Marking the route", Array.from(t.edges.values()), (g) => {
+      const x = T(g.srcId, g.dstId), y = T(g.dstId, g.srcId);
+      p.push({ id: g.id, values: { onPath: d.has(x) || d.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."), {
+    const u = [`Route from ${String(a)} to ${String(i)}.`];
+    return r.hasNegativeCycle && u.push("A loop that costs less every time round was found, so no distance past it is meaningful."), {
       shape: "path",
       fields: [
-        ...Qe,
+        ...tt,
         { name: "distance", kind: "node", type: "number" },
         { name: "hasNegativeCycle", kind: "graph", type: "boolean" }
       ],
       nodes: m,
-      edges: u,
+      edges: p,
       graph: {
-        length: d.length,
-        cost: d.length > 0 ? r.distances.get(i) ?? 0 : 0,
-        hops: Math.max(d.length - 1, 0),
+        length: l.length,
+        cost: l.length > 0 ? r.distances.get(i) ?? 0 : 0,
+        hops: Math.max(l.length - 1, 0),
         hasNegativeCycle: r.hasNegativeCycle
       },
       caveats: M({
         method: "bellman-ford",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "distance" },
-        notes: p
+        notes: u
       })
     };
   }
@@ -558,7 +558,7 @@ const jt = {
     return t;
   }
 };
-W.namespace = "graphty", W.type = "bellman-ford", W.zodOptionsSchema = jt, W.optionsSchema = {
+W.namespace = "graphty", W.type = "bellman-ford", W.zodOptionsSchema = Jt, W.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -574,12 +574,12 @@ W.namespace = "graphty", W.type = "bellman-ford", W.zodOptionsSchema = jt, W.opt
     required: !1
   }
 };
-let ce = W;
-S.register(ce);
-const Vt = 2048;
-function qt(s) {
+let le = W;
+v.register(le);
+const Qt = 2048;
+function _t(o) {
   return {
-    runId: s,
+    runId: o,
     signal: new AbortController().signal,
     report: () => {
     },
@@ -588,14 +588,14 @@ function qt(s) {
     })
   };
 }
-async function F(s, e, t, n) {
-  const a = s.length;
+async function D(o, e, t, n) {
+  const a = o.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()));
+  for (let s = 0; s < a; s++)
+    e.signal.throwIfAborted(), n(o[s], s), (s + 1) % Qt === 0 && s + 1 < a && (e.report({ phase: t, completed: s + 1, total: a }), performance.now() - i >= pt && (await e.yieldNow(), i = performance.now()));
   e.report({ phase: t, completed: a, total: a });
 }
-class G extends S {
+class G extends v {
   /** What the last run published, kept so a caller that has the algorithm can read the result. */
   #e;
   /**
@@ -615,7 +615,7 @@ class G extends S {
    * @returns A promise that settles once the result has been published.
    */
   async run() {
-    await this.measureRun(qt(this.type));
+    await this.measureRun(_t(this.type));
   }
   /**
    * Measure the graph on behalf of a run, and hand the result back.
@@ -642,8 +642,8 @@ class G extends S {
     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 },
+    const a = Date.now(), i = await this.measure(e, n), s = mt(this.graph), r = gt({
+      ...s === void 0 ? {} : { labelOf: s },
       runId: e.runId,
       shape: "node-metric",
       fields: this.resultFields(),
@@ -659,16 +659,16 @@ class G extends S {
     return this.#e = r, r;
   }
 }
-const At = $({
+const ea = $({
   plainName: "Bridging",
   technicalName: "betweenness"
-}), Ee = class Ee extends G {
+}), Re = class Re extends G {
   /**
    * The fields a betweenness result publishes.
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return At;
+    return ea;
   }
   /**
    * Score every node by the shortest paths that run through it.
@@ -684,12 +684,12 @@ const At = $({
       total: t.length,
       message: "Brandes runs a breadth-first search from every node."
     });
-    const a = ut(n);
+    const a = yt(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 } });
+    return await D(t, e, "reading scores", (s) => {
+      const r = a[String(s)];
+      i.push({ id: s, values: r === void 0 ? {} : { value: r } });
     }), {
       nodes: i,
       // Raw counts. `options.normalized` is not set, so nothing rescales them.
@@ -709,10 +709,10 @@ const At = $({
     };
   }
 };
-Ee.namespace = "graphty", Ee.type = "betweenness";
-let le = Ee;
-S.register(le);
-const Bt = {
+Re.namespace = "graphty", Re.type = "betweenness";
+let de = Re;
+v.register(de);
+const ta = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -763,19 +763,19 @@ const Bt = {
     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);
+    const { snapshot: s, run: r } = this.accelerated("breadthFirstSearch", "undirected"), l = this.nodeIndex(s, "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) } });
+    const { value: h, precision: m } = await r((u, g) => u.breadthFirstSearch(g, l)), d = /* @__PURE__ */ new Map();
+    for (let u = 0; u < h.visitedCount; u++)
+      d.set(h.order[u], u);
+    const p = [];
+    return await S(e, "Recording levels", t, (u) => {
+      const g = s.ids.indexOf(u), x = g === F ? F : h.depth[g];
+      x !== F && p.push({ id: u, values: { level: x, order: d.get(g) } });
     }), {
       shape: "layered-grouping",
-      fields: [...qe, { name: "order", kind: "node", type: "integer" }],
-      nodes: u,
+      fields: [...Ze, { name: "order", kind: "node", type: "integer" }],
+      nodes: p,
       caveats: M({
         method: "bfs",
         direction: "undirected",
@@ -797,27 +797,27 @@ const Bt = {
     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, {
+    const s = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+    let l = !1;
+    e.report({ phase: "Walking outwards", total: null }), bt(i, n, {
       targetNode: a,
-      visitCallback: (l, u) => {
-        o.set(l, u), r.set(l, r.size), l === a && (d = !0);
+      visitCallback: (d, p) => {
+        s.set(d, p), r.set(d, r.size), d === a && (l = !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) } });
+    return await S(e, "Recording levels", t, (d) => {
+      const p = s.get(d);
+      p !== void 0 && h.push({ id: d, values: { level: p, order: r.get(d) } });
     }), {
       shape: "layered-grouping",
       fields: [
-        ...qe,
+        ...Ze,
         { name: "order", kind: "node", type: "integer" },
         { name: "targetFound", kind: "graph", type: "boolean" }
       ],
       nodes: h,
-      graph: { targetFound: d },
+      graph: { targetFound: l },
       caveats: M({
         method: "bfs",
         direction: "undirected",
@@ -830,7 +830,7 @@ const Bt = {
     };
   }
 };
-K.namespace = "graphty", K.type = "bfs", K.zodOptionsSchema = Bt, K.optionsSchema = {
+K.namespace = "graphty", K.type = "bfs", K.zodOptionsSchema = ta, K.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -847,9 +847,9 @@ K.namespace = "graphty", K.type = "bfs", K.zodOptionsSchema = Bt, K.optionsSchem
     advanced: !0
   }
 };
-let de = K;
-S.register(de);
-const De = class De extends z {
+let he = K;
+v.register(he);
+const Fe = class Fe extends z {
   /**
    * Pair up the two sides of a two-sided graph so that as many nodes as possible get a partner.
    *
@@ -865,20 +865,20 @@ const De = class De extends z {
     if (t.length === 0)
       return null;
     const n = this.algorithmGraph("undirected"), a = [
-      ...We("edge", { name: "bipartite", type: "boolean" }),
+      ...je("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);
+    const i = wt(n);
     if (i === null) {
-      const l = [];
-      return await N(e, "Marking the pairing", t, (u) => {
-        l.push({ id: u.id, values: { in: !1 } });
+      const d = [];
+      return await S(e, "Marking the pairing", t, (p) => {
+        d.push({ id: p.id, values: { in: !1 } });
       }), {
         shape: "edge-set",
         fields: a,
-        edges: l,
+        edges: d,
         graph: { bipartite: !1 },
         caveats: M({
           method: "bipartite-matching",
@@ -889,49 +889,49 @@ const De = class De extends z {
       };
     }
     e.report({ phase: "Pairing nodes", total: null });
-    const o = gt(n, {
+    const s = vt(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)) } });
+    for (const [d, p] of s.matching)
+      r.add(T(d, p)), r.add(T(p, d));
+    const l = [];
+    await S(e, "Marking the pairing", t, (d) => {
+      l.push({ id: d.id, values: { in: r.has(T(d.srcId, d.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) } });
+    const h = new Set(s.matching.values()), m = [];
+    return await S(e, "Marking sides", Array.from(i.left), (d) => {
+      m.push({ id: d, values: { side: "left", matched: s.matching.has(d) } });
+    }), await S(e, "Marking sides", Array.from(i.right), (d) => {
+      m.push({ id: d, values: { side: "right", matched: h.has(d) } });
     }), {
       shape: "edge-set",
       fields: a,
       nodes: m,
-      edges: d,
+      edges: l,
       graph: { bipartite: !0 },
       caveats: M({
         method: "bipartite-matching",
         direction: "undirected",
         weight: null,
-        notes: [`${String(o.size)} of the two sides' nodes found a partner.`]
+        notes: [`${String(s.size)} of the two sides' nodes found a partner.`]
       })
     };
   }
 };
-De.namespace = "graphty", De.type = "bipartite-matching";
-let he = De;
-S.register(he);
-const Yt = $({
+Fe.namespace = "graphty", Fe.type = "bipartite-matching";
+let ue = Fe;
+v.register(ue);
+const aa = $({
   plainName: "Reach",
   technicalName: "closeness"
-}), Pe = class Pe extends G {
+}), $e = class $e extends G {
   /**
    * The fields a closeness result publishes.
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return Yt;
+    return aa;
   }
   /**
    * Score every node by how short its paths to the rest of the graph are.
@@ -947,12 +947,12 @@ const Yt = $({
       total: t.length,
       message: "A breadth-first search runs from every node."
     });
-    const a = ft(n);
+    const a = Nt(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 } });
+    return await D(t, e, "reading scores", (s) => {
+      const r = a[String(s)];
+      i.push({ id: s, values: r === void 0 ? {} : { value: r } });
     }), {
       nodes: i,
       // The algorithm's own figure, published as it was computed.
@@ -972,10 +972,10 @@ const Yt = $({
     };
   }
 };
-Pe.namespace = "graphty", Pe.type = "closeness";
-let ue = Pe;
-S.register(ue);
-const Re = class Re extends z {
+$e.namespace = "graphty", $e.type = "closeness";
+let pe = $e;
+v.register(pe);
+const Ge = class Ge extends z {
   /**
    * Find the separate pieces of the graph.
    *
@@ -991,14 +991,14 @@ const Re = class Re extends z {
       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 { value: s, precision: r } = await a((h, m) => h.connectedComponents(m)), l = [];
+    return await S(e, "Grouping nodes", t, (h) => {
       const m = i.indexOf(h);
-      d.push({ id: h, values: { group: o.labels[m] ?? 0 } });
+      l.push({ id: h, values: { group: s.labels[m] ?? 0 } });
     }), {
       shape: "community",
-      fields: _(!1),
-      nodes: d,
+      fields: ee(!1),
+      nodes: l,
       caveats: M({
         method: "connected-components",
         direction: "undirected",
@@ -1009,32 +1009,32 @@ const Re = class Re extends z {
     };
   }
 };
-Re.namespace = "graphty", Re.type = "connected-components";
-let pe = Re;
-S.register(pe);
-const Zt = [
+Ge.namespace = "graphty", Ge.type = "connected-components";
+let me = Ge;
+v.register(me);
+const na = [
   ...$({ plainName: "Connections", technicalName: "degree", type: "integer", unit: "links" }),
-  oe({
+  re({
     name: "inDegree",
     plainName: "Incoming connections",
     technicalName: "inDegree",
     kind: "node",
     type: "integer"
   }),
-  oe({
+  re({
     name: "outDegree",
     plainName: "Outgoing connections",
     technicalName: "outDegree",
     kind: "node",
     type: "integer"
   })
-], Fe = class Fe extends G {
+], He = class He extends G {
   /**
    * The fields a degree result publishes.
    * @returns The uniform node-metric fields, plus `inDegree` and `outDegree`.
    */
   resultFields() {
-    return Zt;
+    return na;
   }
   /**
    * Count every node's edges.
@@ -1044,9 +1044,9 @@ const Zt = [
    */
   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 } });
+    return await D(t, e, "counting connections", (i) => {
+      const s = n.inDegree(i), r = n.outDegree(i);
+      a.push({ id: i, values: { value: s + r, inDegree: s, outDegree: r } });
     }), {
       nodes: a,
       // A count of edges, published as it was counted.
@@ -1062,10 +1062,10 @@ const Zt = [
     };
   }
 };
-Fe.namespace = "graphty", Fe.type = "degree";
-let me = Fe;
-S.register(me);
-const Xt = {
+He.namespace = "graphty", He.type = "degree";
+let ge = He;
+v.register(ge);
+const ia = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -1125,25 +1125,25 @@ const Xt = {
     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;
+    const a = this.legacyOptions?.source ?? this._schemaOptions.source ?? n[0], { targetNode: i, recursive: s, preOrder: r } = this._schemaOptions;
     if (!t.nodes.has(a))
       return null;
-    const d = this.algorithmGraph("undirected");
+    const l = this.algorithmGraph("undirected");
     e.report({ phase: "Walking deep", total: null });
-    const h = yt(d, a, {
+    const h = kt(l, a, {
       targetNode: i ?? void 0,
-      recursive: o,
+      recursive: s,
       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) } });
+    h.order.forEach((p, u) => m.set(p, u));
+    const d = [];
+    return await S(e, "Recording the order", n, (p) => {
+      const u = m.get(p);
+      d.push({ id: p, values: { value: u, visited: h.visited.has(p) } });
     }), {
       shape: "node-metric",
-      fields: [...je("node", "integer"), { name: "visited", kind: "node", type: "boolean" }],
-      nodes: l,
+      fields: [...Be("node", "integer"), { name: "visited", kind: "node", type: "boolean" }],
+      nodes: d,
       caveats: M({
         method: "dfs",
         direction: "undirected",
@@ -1153,7 +1153,7 @@ const Xt = {
     };
   }
 };
-L.namespace = "graphty", L.type = "dfs", L.zodOptionsSchema = Xt, L.optionsSchema = {
+L.namespace = "graphty", L.type = "dfs", L.zodOptionsSchema = ia, L.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -1184,9 +1184,9 @@ L.namespace = "graphty", L.type = "dfs", L.zodOptionsSchema = Xt, L.optionsSchem
     advanced: !0
   }
 };
-let ge = L;
-S.register(ge);
-const Jt = {
+let fe = L;
+v.register(fe);
+const sa = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -1238,50 +1238,50 @@ const Jt = {
     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");
+    const { snapshot: a, edgeRemap: i, run: s } = 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);
+    const { ids: r } = a, l = 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", l), d = 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({
+    const { value: p, precision: u } = await s((w, N) => w.sssp(N, m)), g = p.pathTo(d), x = new Set(p.pathEdges(d)), y = /* @__PURE__ */ new Map();
+    g.forEach((w, N) => y.set(w, N));
+    const O = [];
+    await S(e, "Marking the route", n, (w) => {
+      const N = r.indexOf(w), b = N === F ? void 0 : y.get(N);
+      O.push({
         id: w,
         values: {
           onPath: b !== void 0,
           order: b,
-          distance: v === R ? 1 / 0 : u.dist[v]
+          distance: N === F ? 1 / 0 : p.dist[N]
         }
       });
     });
     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) } });
+    return await S(e, "Marking the route", Array.from(t.edges.values()), (w) => {
+      const N = i === null ? w.index : i[w.index] ?? F;
+      I.push({ id: w.id, values: { onPath: x.has(N) } });
     }), {
       shape: "path",
-      fields: [...Qe, { name: "distance", kind: "node", type: "number" }],
-      nodes: k,
+      fields: [...tt, { name: "distance", kind: "node", type: "number" }],
+      nodes: O,
       edges: I,
       graph: {
-        length: f.length,
-        cost: f.length === 0 ? 0 : u.dist[l],
-        hops: Math.max(f.length - 1, 0)
+        length: g.length,
+        cost: g.length === 0 ? 0 : p.dist[d],
+        hops: Math.max(g.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)}.`]
+        precision: u,
+        notes: g.length === 0 ? [`No route runs from ${String(l)} to ${String(h)}.`] : [`Route from ${String(l)} to ${String(h)}.`]
       })
     };
   }
 };
-U.namespace = "graphty", U.type = "dijkstra", U.zodOptionsSchema = Jt, U.optionsSchema = {
+U.namespace = "graphty", U.type = "dijkstra", U.zodOptionsSchema = sa, U.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -1304,9 +1304,9 @@ U.namespace = "graphty", U.type = "dijkstra", U.zodOptionsSchema = Jt, U.options
     advanced: !0
   }
 };
-let fe = U;
-S.register(fe);
-const Qt = {
+let ye = U;
+v.register(ye);
+const oa = {
   maxIterations: {
     schema: c.number().int().min(1).max(1e4).default(1e3),
     meta: {
@@ -1347,16 +1347,16 @@ const Qt = {
       advanced: !0
     }
   }
-}, _t = $({
+}, ra = $({
   plainName: "Influence by association",
   technicalName: "eigenvector score"
-}), P = class P extends G {
+}), R = class R extends G {
   /**
    * The fields an eigenvector result publishes.
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return _t;
+    return ra;
   }
   /**
    * Score every node by the influence of its neighbours.
@@ -1365,49 +1365,49 @@ const Qt = {
    * @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");
+    const { maxIterations: n, tolerance: a, normalized: i, mode: s, endpoints: r } = this.schemaOptions, l = this._schemaOptions.startVector ?? void 0, h = s !== "total" && this.graph.getDataManager().getSnapshot().directed, m = this.algorithmGraph(h ? "directed" : "undirected");
     e.report({
       phase: "iterating",
       completed: 0,
       total: t.length,
       message: `Power iteration, up to ${String(n)} passes.`
     });
-    let m;
+    let d;
     try {
-      m = bt(h, {
+      d = St(m, {
         normalized: i,
         maxIterations: n,
         tolerance: a,
-        mode: o,
+        mode: s,
         endpoints: r,
-        startVector: d
+        startVector: l
       });
     } catch (u) {
-      if (!(u instanceof wt))
+      if (!(u instanceof Ot))
         throw u;
-      const p = `${P.namespace}:${P.type}`;
-      throw new et({
+      const g = `${R.namespace}:${R.type}`;
+      throw new nt({
         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 },
+        details: { algorithm: g, 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 } });
+    const p = [];
+    return await D(t, e, "reading scores", (u) => {
+      const g = d[String(u)];
+      p.push({ id: u, values: g === void 0 ? {} : { value: g } });
     }), {
-      nodes: l,
+      nodes: p,
       // 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",
+        direction: h ? "directed" : "undirected",
         weight: null,
         precision: "f64",
         method: "power-iteration",
@@ -1416,13 +1416,16 @@ const Qt = {
         converged: !0,
         notes: [
           `Power iteration reached a tolerance of ${String(a)} within ${String(n)} passes.`,
+          ...h ? [
+            s === "in" ? "A node is scored by the nodes whose edges point at it." : "A node is scored by the nodes its edges point at."
+          ] : [],
           "Edge weights are not read."
         ]
       }
     };
   }
 };
-P.namespace = "graphty", P.type = "eigenvector", P.zodOptionsSchema = Qt, P.optionsSchema = {
+R.namespace = "graphty", R.type = "eigenvector", R.zodOptionsSchema = oa, R.optionsSchema = {
   maxIterations: {
     type: "integer",
     default: 1e3,
@@ -1469,9 +1472,9 @@ P.namespace = "graphty", P.type = "eigenvector", P.zodOptionsSchema = Qt, P.opti
   }
   // Note: startVector is a Map type - programmatic only, not in schema
 };
-let ye = P;
-S.register(ye);
-const $e = class $e extends z {
+let be = R;
+v.register(be);
+const We = class We extends z {
   /**
    * Measure the distance between every pair of nodes, and give each node the distance to the
    * node furthest from it.
@@ -1495,36 +1498,36 @@ const $e = class $e extends z {
       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 a = xt(n), i = /* @__PURE__ */ new Map();
+    await S(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 d = 0;
+      for (const p of m.values())
+        isFinite(p) && p > d && (d = p);
+      i.set(h, d);
     });
-    let o = 0, r = 1 / 0;
+    let s = 0, r = 1 / 0;
     for (const h of i.values())
-      isFinite(h) && (o = Math.max(o, h), r = Math.min(r, h));
+      isFinite(h) && (s = Math.max(s, h), r = Math.min(r, h));
     r === 1 / 0 && (r = 0);
-    const d = [];
-    return await N(e, "Publishing distances", t, (h) => {
+    const l = [];
+    return await S(e, "Publishing distances", t, (h) => {
       const m = i.get(h) ?? 1 / 0;
-      isFinite(m) && d.push({ id: h, values: { value: m } });
+      isFinite(m) && l.push({ id: h, values: { value: m } });
     }), {
       shape: "node-metric",
       fields: [
-        ...je("node"),
+        ...Be("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 },
+      nodes: l,
+      graph: { diameter: s, radius: r, hasNegativeCycle: a.hasNegativeCycle },
       caveats: M({
         method: "floyd-warshall",
         direction: "undirected",
@@ -1536,10 +1539,10 @@ const $e = class $e extends z {
     };
   }
 };
-$e.namespace = "graphty", $e.type = "floyd-warshall";
-let be = $e;
-S.register(be);
-const ea = {
+We.namespace = "graphty", We.type = "floyd-warshall";
+let we = We;
+v.register(we);
+const ca = {
   maxCommunities: {
     schema: c.number().int().min(0).max(100).default(0),
     meta: {
@@ -1577,29 +1580,29 @@ const ea = {
     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");
+    const { maxCommunities: n, minCommunitySize: a, maxIterations: i } = this.schemaOptions, s = this.algorithmGraph("undirected");
     e.report({ phase: "Cutting bridges", total: null });
-    const r = Nt(o, {
+    const r = It(s, {
       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,
+    }), l = n > 0 ? r.filter((u) => u.communities.length <= n) : r, m = (l.length > 0 ? l : r.slice(0, 1)).reduce(
+      (u, g) => u === void 0 || g.modularity > u.modularity ? g : u,
       void 0
-    ), l = /* @__PURE__ */ new Map();
+    ), d = /* @__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);
+      for (let u = 0; u < m.communities.length; u++)
+        for (const g of m.communities[u])
+          d.set(g, u);
     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 } });
+      t.forEach((u, g) => d.set(u, g));
+    const p = [];
+    return await S(e, "Grouping nodes", t, (u) => {
+      p.push({ id: u, values: { group: d.get(u) ?? 0 } });
     }), {
       shape: "community",
-      fields: _(!0),
-      nodes: u,
+      fields: ee(!0),
+      nodes: p,
       graph: { modularity: m?.modularity ?? 0 },
       caveats: M({
         method: "girvan-newman",
@@ -1610,7 +1613,7 @@ const ea = {
     };
   }
 };
-j.namespace = "graphty", j.type = "girvan-newman", j.zodOptionsSchema = ea, j.optionsSchema = {
+j.namespace = "graphty", j.type = "girvan-newman", j.zodOptionsSchema = ca, j.optionsSchema = {
   maxCommunities: {
     type: "integer",
     default: 0,
@@ -1638,9 +1641,9 @@ j.namespace = "graphty", j.type = "girvan-newman", j.zodOptionsSchema = ea, j.op
     advanced: !0
   }
 };
-let we = j;
-S.register(we);
-const ta = {
+let ve = j;
+v.register(ve);
+const la = {
   maxIterations: {
     schema: c.number().int().min(1).max(1e3).default(100),
     meta: {
@@ -1681,10 +1684,10 @@ const ta = {
       advanced: !0
     }
   }
-}, aa = [
+}, da = [
   ...$({ plainName: "Hub and authority", technicalName: "combined HITS score" }),
-  oe({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
-  oe({
+  re({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
+  re({
     name: "authority",
     plainName: "Authority",
     technicalName: "authority score",
@@ -1697,7 +1700,7 @@ const ta = {
    * @returns The uniform node-metric fields, plus `hub` and `authority`.
    */
   resultFields() {
-    return aa;
+    return da;
   }
   /**
    * Score every node as a hub and as an authority.
@@ -1706,29 +1709,29 @@ const ta = {
    * @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");
+    const { maxIterations: n, tolerance: a, normalized: i, mode: s, endpoints: r } = this.schemaOptions, l = 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, {
+    const h = Mt(l, {
       maxIterations: n,
       tolerance: a,
       normalized: i,
-      mode: o,
+      mode: s,
       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 await D(t, e, "reading scores", (d) => {
+      const p = h.hubs[String(d)], u = h.authorities[String(d)];
+      if (p === void 0 || u === void 0) {
+        m.push({ id: d, values: {} });
         return;
       }
-      m.push({ id: l, values: { value: (u + p) / 2, hub: u, authority: p } });
+      m.push({ id: d, values: { value: (p + u) / 2, hub: p, authority: u } });
     }), {
       nodes: m,
       // The combined score is the average of two vectors the algorithm scaled, which leaves
@@ -1753,7 +1756,7 @@ const ta = {
     };
   }
 };
-V.namespace = "graphty", V.type = "hits", V.zodOptionsSchema = ta, V.optionsSchema = {
+V.namespace = "graphty", V.type = "hits", V.zodOptionsSchema = la, V.optionsSchema = {
   maxIterations: {
     type: "integer",
     default: 100,
@@ -1799,9 +1802,9 @@ V.namespace = "graphty", V.type = "hits", V.zodOptionsSchema = ta, V.optionsSche
     advanced: !0
   }
 };
-let ve = V;
-S.register(ve);
-const na = {
+let Ne = V;
+v.register(Ne);
+const ha = {
   alpha: {
     schema: c.number().min(0.01).max(0.5).default(0.1),
     meta: {
@@ -1859,7 +1862,7 @@ const na = {
       advanced: !0
     }
   }
-}, ia = $({
+}, ua = $({
   plainName: "Influence at a distance",
   technicalName: "Katz score"
 }), q = class q extends G {
@@ -1868,7 +1871,7 @@ const na = {
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return ia;
+    return ua;
   }
   /**
    * Score every node by the paths that reach it.
@@ -1877,29 +1880,29 @@ const na = {
    * @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");
+    const { alpha: n, beta: a, maxIterations: i, tolerance: s, normalized: r, mode: l, 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, {
+    const d = Ct(m, {
       normalized: r,
       alpha: n,
       beta: a,
       maxIterations: i,
-      tolerance: o,
-      mode: d,
+      tolerance: s,
+      mode: l,
       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 } });
+    const p = [];
+    return await D(t, e, "reading scores", (u) => {
+      const g = d[String(u)];
+      p.push({ id: u, values: g === void 0 ? {} : { value: g } });
     }), {
-      nodes: u,
+      nodes: p,
       // 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",
@@ -1913,7 +1916,7 @@ const na = {
         // 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.`,
+          `Iteration stops at a tolerance of ${String(s)} 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."
         ]
@@ -1921,7 +1924,7 @@ const na = {
     };
   }
 };
-q.namespace = "graphty", q.type = "katz", q.zodOptionsSchema = na, q.optionsSchema = {
+q.namespace = "graphty", q.type = "katz", q.zodOptionsSchema = ha, q.optionsSchema = {
   alpha: {
     type: "number",
     default: 0.1,
@@ -1986,9 +1989,54 @@ q.namespace = "graphty", q.type = "katz", q.zodOptionsSchema = na, q.optionsSche
     advanced: !0
   }
 };
-let Ne = q;
-S.register(Ne);
-const Ge = class Ge extends z {
+let ke = q;
+v.register(ke);
+const pa = $({
+  plainName: "Core depth",
+  technicalName: "core number",
+  type: "integer"
+}), Ke = class Ke extends G {
+  /**
+   * The fields a k-core result publishes.
+   * @returns The uniform node-metric fields.
+   */
+  resultFields() {
+    return pa;
+  }
+  /**
+   * Give every node its core number.
+   * @param context - Where progress goes and where cancellation arrives.
+   * @param nodeIds - The nodes to measure.
+   * @returns One core number per node.
+   */
+  async measure(e, t) {
+    const n = this.algorithmGraph("undirected");
+    e.report({ phase: "peeling cores", total: null });
+    const { coreness: a } = zt(n);
+    e.signal.throwIfAborted();
+    const i = [];
+    return await D(t, e, "reading core numbers", (s) => {
+      const r = a.get(String(s));
+      i.push({ id: s, values: r === void 0 ? {} : { value: r } });
+    }), {
+      nodes: i,
+      // A count of neighbours, published as it was counted.
+      normalization: "none",
+      caveats: {
+        exact: !0,
+        direction: "undirected",
+        weight: null,
+        precision: "f64",
+        method: "k-core",
+        notes: ["Counted over the graph read as undirected; edge weights are not read."]
+      }
+    };
+  }
+};
+Ke.namespace = "graphty", Ke.type = "k-core";
+let Se = Ke;
+v.register(Se);
+const Le = class Le extends z {
   /**
    * Find the cheapest set of edges that still joins every node.
    *
@@ -2004,29 +2052,29 @@ const Ge = class Ge extends z {
       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) } });
+    const { value: i, precision: s } = await a((h, m) => h.minimumSpanningTree(m)), r = new Set(i.edges), l = [];
+    return await S(e, "Marking the network", t, (h) => {
+      const m = n === null ? h.index : n[h.index] ?? F;
+      l.push({ id: h.id, values: { in: r.has(m) } });
     }), {
       shape: "edge-set",
-      fields: We("edge", { name: "totalWeight", type: "number" }),
-      edges: d,
+      fields: je("edge", { name: "totalWeight", type: "number" }),
+      edges: l,
       graph: { totalWeight: i.totalWeight },
       caveats: M({
         method: "kruskal",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "distance" },
-        precision: o,
+        precision: s,
         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 = {
+Le.namespace = "graphty", Le.type = "kruskal";
+let Oe = Le;
+v.register(Oe);
+const ma = {
   maxIterations: {
     schema: c.number().int().min(1).max(500).default(100),
     meta: {
@@ -2059,29 +2107,29 @@ const sa = {
       return null;
     const { maxIterations: n, randomSeed: a } = this.schemaOptions, i = this.algorithmGraph("undirected");
     e.report({ phase: "Spreading labels", total: null });
-    const o = Ot(i, {
+    const s = Tt(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 } });
+    return await S(e, "Grouping nodes", t, (l) => {
+      r.push({ id: l, values: { group: s.communities.get(String(l)) ?? 0 } });
     }), {
       shape: "community",
-      fields: _(!1),
+      fields: ee(!1),
       nodes: r,
       caveats: M({
         method: "label-propagation",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "strength" },
-        converged: o.converged,
-        iterations: o.iterations,
+        converged: s.converged,
+        iterations: s.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 = {
+A.namespace = "graphty", A.type = "label-propagation", A.zodOptionsSchema = ma, A.optionsSchema = {
   maxIterations: {
     type: "integer",
     default: 100,
@@ -2100,9 +2148,9 @@ A.namespace = "graphty", A.type = "label-propagation", A.zodOptionsSchema = sa,
     advanced: !0
   }
 };
-let Se = A;
-S.register(Se);
-const oa = {
+let xe = A;
+v.register(xe);
+const ga = {
   resolution: {
     schema: c.number().min(0.1).max(5).default(1),
     meta: {
@@ -2149,32 +2197,32 @@ const oa = {
     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");
+    const { resolution: n, randomSeed: a, maxIterations: i, threshold: s } = this.schemaOptions, r = this.algorithmGraph("undirected");
     e.report({ phase: "Refining communities", total: null });
-    const d = xt(r, {
+    const l = Et(r, {
       resolution: n,
       randomSeed: a,
       maxIterations: i,
-      threshold: o
+      threshold: s
     }), h = [];
-    return await N(e, "Grouping nodes", t, (m) => {
-      h.push({ id: m, values: { group: d.communities.get(String(m)) ?? 0 } });
+    return await S(e, "Grouping nodes", t, (m) => {
+      h.push({ id: m, values: { group: l.communities.get(String(m)) ?? 0 } });
     }), {
       shape: "community",
-      fields: _(!0),
+      fields: ee(!0),
       nodes: h,
-      graph: { modularity: d.modularity },
+      graph: { modularity: l.modularity },
       caveats: M({
         method: "leiden",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "strength" },
-        iterations: d.iterations,
+        iterations: l.iterations,
         notes: [`Resolution ${String(n)}.`]
       })
     };
   }
 };
-B.namespace = "graphty", B.type = "leiden", B.zodOptionsSchema = oa, B.optionsSchema = {
+B.namespace = "graphty", B.type = "leiden", B.zodOptionsSchema = ga, B.optionsSchema = {
   resolution: {
     type: "number",
     default: 1,
@@ -2212,9 +2260,79 @@ B.namespace = "graphty", B.type = "leiden", B.zodOptionsSchema = oa, B.optionsSc
     advanced: !0
   }
 };
-let Oe = B;
-S.register(Oe);
-const ra = {
+let Ie = B;
+v.register(Ie);
+const fa = {
+  "adamic-adar": Pt,
+  "common-neighbors": Dt
+}, ya = {
+  method: {
+    schema: c.enum(["adamic-adar", "common-neighbors"]).default("adamic-adar"),
+    meta: {
+      label: "Method",
+      description: "Common neighbours counts the neighbours two nodes share. Adamic-Adar counts them too, but a shared neighbour with few connections counts for more than one with many."
+    }
+  },
+  topK: {
+    schema: c.number().int().min(1).max(1e3).default(10),
+    meta: {
+      label: "Pairs",
+      description: "How many of the best-scoring pairs to keep."
+    }
+  }
+}, Y = class Y extends z {
+  /**
+   * Score every unconnected pair of nodes and keep the best.
+   * @param context - What the element gave the run.
+   * @returns The scored pairs, best first, or null when the graph has no nodes.
+   */
+  compute(e) {
+    if (this.graph.getDataManager().nodes.size === 0)
+      return Promise.resolve(null);
+    const { method: t, topK: n } = this.schemaOptions, a = this.algorithmGraph("undirected");
+    e.report({ phase: "Scoring pairs", total: null });
+    const i = /* @__PURE__ */ new Set(), s = fa[t](a).filter(({ source: r, target: l }) => {
+      const h = [String(r), String(l)].sort().join("\0");
+      return i.has(h) ? !1 : (i.add(h), !0);
+    }).slice(0, n);
+    return e.signal.throwIfAborted(), Promise.resolve({
+      shape: "pair-list",
+      fields: [{ name: "pairs", kind: "graph", type: "table" }],
+      graph: { pairs: s },
+      caveats: M({
+        method: t,
+        direction: "undirected",
+        weight: null,
+        notes: [
+          "Only pairs that are not already joined, and that share at least one neighbour, are scored."
+        ]
+      })
+    });
+  }
+};
+Y.namespace = "graphty", Y.type = "link-prediction", Y.zodOptionsSchema = ya, Y.optionsSchema = {
+  method: {
+    type: "select",
+    default: "adamic-adar",
+    label: "Method",
+    description: "Common neighbours counts the neighbours two nodes share. Adamic-Adar counts them too, but a shared neighbour with few connections counts for more than one with many.",
+    options: [
+      { value: "adamic-adar", label: "Adamic-Adar" },
+      { value: "common-neighbors", label: "Common neighbours" }
+    ]
+  },
+  topK: {
+    type: "integer",
+    default: 10,
+    label: "Pairs",
+    description: "How many of the best-scoring pairs to keep.",
+    min: 1,
+    max: 1e3
+  }
+};
+let Me = Y;
+v.register(Me);
+const ba = {
   resolution: {
     schema: c.number().min(0.1).max(5).default(1),
     meta: {
@@ -2247,7 +2365,7 @@ const ra = {
       advanced: !0
     }
   }
-}, Y = class Y extends z {
+}, Z = class Z extends z {
   /**
    * Group the nodes into communities by optimising modularity.
    *
@@ -2261,25 +2379,25 @@ const ra = {
     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");
+    const { resolution: n, maxIterations: a, tolerance: i, useOptimized: s } = this.schemaOptions, r = this.algorithmGraph("undirected");
     e.report({ phase: "Optimizing modularity", total: null });
-    const d = It(r, {
+    const l = Rt(r, {
       resolution: n,
       maxIterations: a,
       tolerance: i,
-      useOptimized: o
+      useOptimized: s
     }), h = /* @__PURE__ */ new Map();
-    for (let l = 0; l < d.communities.length; l++)
-      for (const u of d.communities[l])
-        h.set(u, l);
+    for (let d = 0; d < l.communities.length; d++)
+      for (const p of l.communities[d])
+        h.set(p, d);
     const m = [];
-    return await N(e, "Grouping nodes", t, (l) => {
-      m.push({ id: l, values: { group: h.get(l) ?? 0 } });
+    return await S(e, "Grouping nodes", t, (d) => {
+      m.push({ id: d, values: { group: h.get(d) ?? 0 } });
     }), {
       shape: "community",
-      fields: _(!0),
+      fields: ee(!0),
       nodes: m,
-      graph: { modularity: d.modularity },
+      graph: { modularity: l.modularity },
       caveats: M({
         method: "louvain",
         direction: "undirected",
@@ -2289,7 +2407,7 @@ const ra = {
     };
   }
 };
-Y.namespace = "graphty", Y.type = "louvain", Y.zodOptionsSchema = ra, Y.optionsSchema = {
+Z.namespace = "graphty", Z.type = "louvain", Z.zodOptionsSchema = ba, Z.optionsSchema = {
   resolution: {
     type: "number",
     default: 1,
@@ -2325,9 +2443,9 @@ Y.namespace = "graphty", Y.type = "louvain", Y.zodOptionsSchema = ra, Y.optionsS
     advanced: !0
   }
 };
-let xe = Y;
-S.register(xe);
-const ca = {
+let Ce = Z;
+v.register(Ce);
+const wa = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -2342,7 +2460,7 @@ const ca = {
       description: "Sink node for flow network (uses last node if not set)"
     }
   }
-}, Z = class Z extends z {
+}, X = class X extends z {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -2371,57 +2489,57 @@ const ca = {
     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 });
+    const i = this.legacyOptions?.source ?? this._schemaOptions.source, s = this.legacyOptions?.sink ?? this._schemaOptions.sink, r = i === null ? String(a[0]) : ce("max-flow", "source", i, a), l = s === null ? String(a[a.length - 1]) : ce("max-flow", "sink", s, a), h = new at({ 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);
+      const O = String(y.srcId), I = String(y.dstId), w = y.data, N = y, b = w?.capacity ?? w?.value ?? N.value ?? 1, C = typeof b == "number" ? b : 1;
+      h.addEdge(O, I, C), m.set(T(O, 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 d = Ft(h, r, l), p = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map();
+    for (const [y, O] of d.flowGraph)
+      for (const [I, w] of O)
+        u.set(y, (u.get(y) ?? 0) + w), p.set(I, (p.get(I) ?? 0) + w);
+    const g = [];
+    await S(e, "Measuring edges", n, (y) => {
+      const O = String(y.srcId), I = String(y.dstId), w = d.flowGraph.get(O)?.get(I) ?? 0, N = m.get(T(O, I)) ?? 1, b = N > 0 ? Math.abs(w) / N : 0;
+      g.push({ id: y.id, values: { value: w, capacity: N, 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 });
+    const x = [];
+    return await S(e, "Measuring nodes", a, (y) => {
+      const O = String(y), I = p.get(O) ?? 0, w = u.get(O) ?? 0, N = { netFlow: I - w };
+      O === r ? N.role = "source" : O === l && (N.role = "sink"), x.push({ id: y, values: N });
     }), {
       shape: "edge-metric",
       fields: [
-        ...je("edge"),
+        ...Be("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 },
+      nodes: x,
+      edges: g,
+      graph: { maxFlow: d.maxFlow },
       caveats: M({
         method: "ford-fulkerson",
         direction: "directed",
         weight: { attribute: "capacity", meaning: "strength" },
         notes: [
-          `Flow from ${r} to ${d}.`,
-          ...i === null || o === null ? [
+          `Flow from ${r} to ${l}.`,
+          ...i === null || s === 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.`] : []
+          ...d.maxFlow === 0 ? [`There is no directed path from ${r} to ${l}, so no flow can run.`] : []
         ]
       })
     };
   }
 };
-Z.namespace = "graphty", Z.type = "max-flow", Z.zodOptionsSchema = ca, Z.optionsSchema = {
+X.namespace = "graphty", X.type = "max-flow", X.zodOptionsSchema = wa, X.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -2437,9 +2555,9 @@ Z.namespace = "graphty", Z.type = "max-flow", Z.zodOptionsSchema = ca, Z.options
     required: !1
   }
 };
-let Ie = Z;
-S.register(Ie);
-const la = {
+let ze = X;
+v.register(ze);
+const va = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -2477,7 +2595,7 @@ const la = {
       advanced: !0
     }
   }
-}, X = class X extends z {
+}, J = class J extends z {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -2512,58 +2630,58 @@ const la = {
     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 });
+    const i = /* @__PURE__ */ new Map(), s = new at({ directed: !1 });
     for (const b of a)
-      i.set(String(b), /* @__PURE__ */ new Map()), o.addNode(String(b));
+      i.set(String(b), /* @__PURE__ */ new Map()), s.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 C = String(b.srcId), P = String(b.dstId), H = b.data, ne = b, Ye = H?.value ?? ne.value ?? 1, Ve = typeof Ye == "number" ? Ye : 1;
+      i.get(C)?.set(P, Ve), i.get(P)?.set(C, Ve), s.addEdge(C, P, Ve);
     }
-    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));
+    const r = this.legacyOptions?.useGlobalMinCut ?? this._schemaOptions.useGlobalMinCut, l = this.legacyOptions?.source ?? this._schemaOptions.source, h = this.legacyOptions?.sink ?? this._schemaOptions.sink, { useKarger: m, kargerIterations: d } = this._schemaOptions;
+    let p, u, g, x, y, O;
+    if (e.report({ phase: "Finding the cut", total: null }), r || l === null && h === null)
+      m ? (y = "karger", { partition1: p, partition2: u, cutEdges: g, cutValue: x } = $t(i, d)) : (y = "stoer-wagner", { partition1: p, partition2: u, cutEdges: g, cutValue: x } = Gt(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 b = l === null ? String(a[0]) : ce("min-cut", "source", l, a), C = h === null ? String(a[a.length - 1]) : ce("min-cut", "sink", h, a);
+      (l === null || h === null) && (O = `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: p, partition2: u, cutEdges: g, cutValue: x } = Ht(s, b, C);
     }
     const I = /* @__PURE__ */ new Map();
-    for (const b of f)
+    for (const b of g)
       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) => {
+    await S(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" } });
+    const N = [];
+    return await S(e, "Marking the sides", a, (b) => {
+      const C = p.has(String(b));
+      N.push({ id: b, values: { side: C ? "1" : "2" } });
     }), {
       shape: "edge-set",
       fields: [
-        ...We("edge", { name: "cutValue", type: "number" }),
+        ...je("edge", { name: "cutValue", type: "number" }),
         { name: "side", kind: "node", type: "string" }
       ],
-      nodes: v,
+      nodes: N,
       edges: w,
-      graph: { cutValue: O },
+      graph: { cutValue: x },
       caveats: M({
         method: y,
         direction: "undirected",
         weight: { attribute: "weight", meaning: "strength" },
         exact: y !== "karger",
-        iterations: y === "karger" ? l : void 0,
+        iterations: y === "karger" ? d : 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]
+          y === "karger" ? "Karger's method is randomised: it finds the cheapest cut with high probability, not certainty." : `The cut separates ${String(p.size)} nodes from ${String(u.size)}.`,
+          ...O === void 0 ? [] : [O]
         ]
       })
     };
   }
 };
-X.namespace = "graphty", X.type = "min-cut", X.zodOptionsSchema = la, X.optionsSchema = {
+J.namespace = "graphty", J.type = "min-cut", J.zodOptionsSchema = va, J.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -2602,9 +2720,9 @@ X.namespace = "graphty", X.type = "min-cut", X.zodOptionsSchema = la, X.optionsS
     advanced: !0
   }
 };
-let Me = X;
-S.register(Me);
-const Ze = {
+let Te = J;
+v.register(Te);
+const _e = {
   dampingFactor: {
     schema: c.number().min(0).max(1).default(0.85),
     meta: {
@@ -2645,21 +2763,21 @@ const Ze = {
       advanced: !0
     }
   }
-}, da = $({
+}, Na = $({
   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";
+}), ka = 100;
+function Sa(o) {
+  return o.hasPersonalization ? "a personalization vector was given, and only the reference implementation takes one" : o.hasInitialRanks ? "initial ranks were given, and only the reference implementation takes them" : o.directed ? null : "the graph is undirected, and rank flows along out-edges";
 }
-const J = class J extends G {
+const Q = class Q 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 = {
+    super(e, t), this.zodOptions = Xt(_e, t ?? {}), this.programmaticOptions = {
       initialRanks: t?.initialRanks ?? null,
       personalization: t?.personalization ?? null
     };
@@ -2669,7 +2787,7 @@ const J = class J extends G {
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return da;
+    return Na;
   }
   /**
    * Rank every node by the influence flowing into it.
@@ -2678,40 +2796,40 @@ const J = class J extends G {
    * @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({
+    const { dampingFactor: n, maxIterations: a, tolerance: i, weight: s, useDelta: r } = this.zodOptions, l = this.programmaticOptions.initialRanks ?? void 0, h = this.programmaticOptions.personalization ?? void 0, m = Sa({
       directed: this.graph.getDataManager().getSnapshot().directed,
-      hasInitialRanks: d !== void 0,
+      hasInitialRanks: l !== void 0,
       hasPersonalization: h !== void 0
     });
     if (m === null) {
-      const { snapshot: y, run: k } = this.accelerated("pageRank", "directed");
+      const { snapshot: y, run: O } = 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, {
+      const { value: I, precision: w } = await O(
+        (P, H) => P.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
+          weighted: s !== 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 { ids: N } = y, b = [];
+      await D(t, e, "reading ranks", (P) => {
+        const H = N.indexOf(P), ne = H === F ? void 0 : I.scores[H];
+        b.push({ id: P, values: ne === void 0 ? {} : { value: ne } });
       });
       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(
+      return s === 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,
@@ -2719,7 +2837,7 @@ const J = class J extends G {
         caveats: {
           exact: !0,
           direction: "directed",
-          weight: o === null ? null : { attribute: o, meaning: "strength" },
+          weight: s === null ? null : { attribute: s, meaning: "strength" },
           precision: w,
           method: "power-iteration",
           converged: I.converged,
@@ -2728,54 +2846,51 @@ const J = class J extends G {
         }
       };
     }
-    const l = this.algorithmGraph("directed"), u = r && l.nodeCount > ha;
+    const d = this.algorithmGraph("directed"), p = r && d.nodeCount > ka;
     e.report({
       phase: "iterating",
       completed: 0,
       total: t.length,
       message: `Power iteration, up to ${String(a)} passes.`
     });
-    const p = Et(l, {
+    const u = Wt(d, {
       dampingFactor: n,
       maxIterations: a,
       tolerance: i,
-      weight: o ?? void 0,
+      weight: s ?? void 0,
       useDelta: r,
-      initialRanks: d,
+      initialRanks: l,
       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 g = [];
+    await D(t, e, "reading ranks", (y) => {
+      const O = u.ranks[String(y)];
+      g.push({ id: y, values: O === void 0 ? {} : { value: O } });
     });
-    const O = [
+    const x = [
       `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,
+    return s === null && x.push("Edge weights are not read."), {
+      nodes: g,
       // Raw ranks, published as they were computed.
       normalization: "none",
       caveats: {
         exact: !0,
         direction: "directed",
-        weight: o === null ? null : { attribute: o, meaning: "strength" },
+        weight: s === null ? null : { attribute: s, 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
+        method: p ? "delta-pagerank" : "power-iteration",
+        converged: u.converged,
+        iterations: u.iterations,
+        notes: x
       }
     };
   }
 };
-J.namespace = "graphty", J.type = "pagerank", J.zodOptionsSchema = Ze, J.optionsSchema = {
+Q.namespace = "graphty", Q.type = "pagerank", Q.zodOptionsSchema = _e, Q.optionsSchema = {
   dampingFactor: {
     type: "number",
     default: 0.85,
@@ -2819,9 +2934,9 @@ J.namespace = "graphty", J.type = "pagerank", J.zodOptionsSchema = Ze, J.options
   }
   // Note: initialRanks and personalization are Map types - programmatic only, not in schema
 };
-let Ce = J;
-S.register(Ce);
-const pa = {
+let Ee = Q;
+v.register(Ee);
+const Oa = {
   startNode: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -2829,7 +2944,7 @@ const pa = {
       description: "Starting node for MST growth (uses first node if not set)"
     }
   }
-}, Q = class Q extends z {
+}, _ = class _ extends z {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -2858,15 +2973,15 @@ const pa = {
       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 i = Kt(a, n), s = /* @__PURE__ */ new Set();
+    for (const l of i.edges)
+      s.add(T(l.source, l.target)), s.add(T(l.target, l.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)) } });
+    return await S(e, "Marking the network", t, (l) => {
+      r.push({ id: l.id, values: { in: s.has(T(l.srcId, l.dstId)) } });
     }), {
       shape: "edge-set",
-      fields: We("edge", { name: "totalWeight", type: "number" }),
+      fields: je("edge", { name: "totalWeight", type: "number" }),
       edges: r,
       graph: { totalWeight: i.totalWeight },
       caveats: M({
@@ -2878,7 +2993,7 @@ const pa = {
     };
   }
 };
-Q.namespace = "graphty", Q.type = "prim", Q.zodOptionsSchema = pa, Q.optionsSchema = {
+_.namespace = "graphty", _.type = "prim", _.zodOptionsSchema = Oa, _.optionsSchema = {
   startNode: {
     type: "nodeId",
     default: null,
@@ -2887,9 +3002,9 @@ Q.namespace = "graphty", Q.type = "prim", Q.zodOptionsSchema = pa, Q.optionsSche
     required: !1
   }
 };
-let ze = Q;
-S.register(ze);
-const He = class He extends z {
+let De = _;
+v.register(De);
+const Ue = class Ue extends z {
   /**
    * Find the pieces of the graph that a directed path can cross both ways.
    *
@@ -2905,17 +3020,17 @@ const He = class He extends z {
       return null;
     const n = this.algorithmGraph("directed");
     e.report({ phase: "Finding pieces", total: null });
-    const a = Pt(n), i = /* @__PURE__ */ new Map();
+    const a = Lt(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 } });
+      for (const l of a[r])
+        i.set(l, r);
+    const s = [];
+    return await S(e, "Grouping nodes", t, (r) => {
+      s.push({ id: r, values: { group: i.get(r) ?? 0 } });
     }), {
       shape: "community",
-      fields: _(!1),
-      nodes: o,
+      fields: ee(!1),
+      nodes: s,
       caveats: M({
         method: "strongly-connected-components",
         direction: "directed",
@@ -2925,38 +3040,38 @@ const He = class He extends z {
     };
   }
 };
-He.namespace = "graphty", He.type = "scc";
-let Te = He;
-S.register(Te);
-const ma = "results.$";
-function g(s) {
-  return { ...s, path: `${ma}.${s.name}` };
+Ue.namespace = "graphty", Ue.type = "scc";
+let Pe = Ue;
+v.register(Pe);
+const xa = "results.$";
+function f(o) {
+  return { ...o, path: `${xa}.${o.name}` };
 }
-function E(s, e) {
+function E(o, e) {
   return [
-    g({
+    f({
       name: "value",
       plainName: e.plainName,
       technicalName: e.technicalName,
-      kind: s,
+      kind: o,
       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({
+    f({ name: "rank", plainName: "Rank", technicalName: "rank", kind: o, type: "integer" }),
+    f({ name: "percentile", plainName: "Percentile", technicalName: "percentile", kind: o, type: "number" }),
+    f({ name: "min", plainName: "Lowest", technicalName: "min", kind: "graph", type: "number" }),
+    f({ name: "max", plainName: "Highest", technicalName: "max", kind: "graph", type: "number" }),
+    f({ name: "median", plainName: "Middle", technicalName: "median", kind: "graph", type: "number" }),
+    f({ name: "mean", plainName: "Average", technicalName: "mean", kind: "graph", type: "number" }),
+    f({ name: "measured", plainName: "Measured", technicalName: "measured", kind: "graph", type: "integer" }),
+    f({
       name: "normalization",
       plainName: "Normalization",
       technicalName: "normalization",
       kind: "graph",
       type: "string"
     }),
-    g({
+    f({
       name: "tiedAtMin",
       plainName: "Tied at the lowest value",
       technicalName: "tiedAtMin",
@@ -2965,33 +3080,33 @@ function E(s, e) {
     })
   ];
 }
-function ee(s, e) {
+function te(o, e) {
   const t = [
-    g({ name: "group", plainName: s, technicalName: "group", kind: "node", type: "integer" }),
-    g({
+    f({ name: "group", plainName: o, technicalName: "group", kind: "node", type: "integer" }),
+    f({
       name: "groupSize",
-      plainName: `${s} size`,
+      plainName: `${o} size`,
       technicalName: "groupSize",
       kind: "node",
       type: "integer"
     }),
-    g({
+    f({
       name: "groupCount",
-      plainName: `${s} count`,
+      plainName: `${o} count`,
       technicalName: "groupCount",
       kind: "graph",
       type: "integer"
     }),
-    g({
+    f({
       name: "sizes",
-      plainName: `${s} sizes`,
+      plainName: `${o} sizes`,
       technicalName: "sizes",
       kind: "graph",
       type: "table"
     })
   ];
   return e && t.push(
-    g({
+    f({
       name: "modularity",
       plainName: "Community strength",
       technicalName: "modularity",
@@ -3000,24 +3115,24 @@ function ee(s, e) {
     })
   ), t;
 }
-function se(s, e, t) {
+function oe(o, 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" })
+    f({ name: "in", plainName: e, technicalName: "in", kind: o, type: "boolean" }),
+    f({ name: "count", plainName: "Count", technicalName: "count", kind: "graph", type: "integer" }),
+    f({ ...t, kind: "graph" })
   ];
 }
-function x(s) {
-  return Ue(s.getZodOptionsSchema());
+function k(o) {
+  return Ae(o.getZodOptionsSchema());
 }
-function Xe(...s) {
+function et(...o) {
   const e = [], t = /* @__PURE__ */ new Set();
-  for (const n of s)
+  for (const n of o)
     for (const a of n)
       t.has(a.name) || (t.add(a.name), e.push(a));
   return e;
 }
-const ga = {
+const Ia = {
   method: {
     schema: c.enum(["dijkstra", "bellman-ford"]).nullable().default(null),
     meta: {
@@ -3027,7 +3142,7 @@ const ga = {
       group: "engine"
     }
   }
-}, fa = {
+}, Ma = {
   strength: {
     schema: c.enum(["weak", "strong"]).default("weak"),
     meta: {
@@ -3035,7 +3150,7 @@ const ga = {
       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 = [
+}, ot = [
   {
     key: "degree",
     plainName: "Connections",
@@ -3045,14 +3160,14 @@ const ga = {
     shape: "node-metric",
     fields: [
       ...E("node", { plainName: "Connections", technicalName: "degree", type: "integer", unit: "links" }),
-      g({
+      f({
         name: "inDegree",
         plainName: "Incoming connections",
         technicalName: "inDegree",
         kind: "node",
         type: "integer"
       }),
-      g({
+      f({
         name: "outDegree",
         plainName: "Outgoing connections",
         technicalName: "outDegree",
@@ -3060,7 +3175,7 @@ const ga = {
         type: "integer"
       })
     ],
-    options: x(me),
+    options: k(ge),
     costClass: "instant",
     complexity: "O(n + m)",
     legacyKeys: [{ key: "degree" }]
@@ -3073,7 +3188,7 @@ const ga = {
     category: "centrality",
     shape: "node-metric",
     fields: E("node", { plainName: "Bridging", technicalName: "betweenness" }),
-    options: x(le),
+    options: k(de),
     costClass: "heavy",
     complexity: "O(n * m)",
     legacyKeys: [{ key: "betweenness" }]
@@ -3086,7 +3201,7 @@ const ga = {
     category: "centrality",
     shape: "node-metric",
     fields: E("node", { plainName: "Reach", technicalName: "closeness" }),
-    options: x(ue),
+    options: k(pe),
     costClass: "heavy",
     complexity: "O(n * m)",
     legacyKeys: [{ key: "closeness" }]
@@ -3099,7 +3214,7 @@ const ga = {
     category: "centrality",
     shape: "node-metric",
     fields: E("node", { plainName: "Influence", technicalName: "PageRank score" }),
-    options: x(Ce),
+    options: k(Ee),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "pagerank" }]
@@ -3112,7 +3227,7 @@ const ga = {
     category: "centrality",
     shape: "node-metric",
     fields: E("node", { plainName: "Influence by association", technicalName: "eigenvector score" }),
-    options: x(ye),
+    options: k(be),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "eigenvector" }]
@@ -3125,7 +3240,7 @@ const ga = {
     category: "centrality",
     shape: "node-metric",
     fields: E("node", { plainName: "Influence at a distance", technicalName: "Katz score" }),
-    options: x(Ne),
+    options: k(ke),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "katz" }]
@@ -3139,8 +3254,8 @@ const ga = {
     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({
+      f({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
+      f({
         name: "authority",
         plainName: "Authority",
         technicalName: "authority score",
@@ -3148,7 +3263,7 @@ const ga = {
         type: "number"
       })
     ],
-    options: x(ve),
+    options: k(Ne),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "hits" }]
@@ -3160,8 +3275,8 @@ const ga = {
     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),
+    fields: te("Community", !0),
+    options: k(Ce),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "louvain" }]
@@ -3173,8 +3288,8 @@ const ga = {
     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),
+    fields: te("Community", !0),
+    options: k(Ie),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "leiden" }]
@@ -3186,8 +3301,8 @@ const ga = {
     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),
+    fields: te("Community", !1),
+    options: k(xe),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "label-propagation" }]
@@ -3199,8 +3314,8 @@ const ga = {
     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),
+    fields: te("Community", !0),
+    options: k(ve),
     costClass: "heavy",
     complexity: "O(n * m^2)",
     legacyKeys: [{ key: "girvan-newman" }]
@@ -3212,11 +3327,11 @@ const ga = {
     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)
+    fields: te("Piece", !1),
+    options: et(
+      k(me),
+      k(Pe),
+      Ae(Ma)
     ),
     costClass: "instant",
     complexity: "O(n + m)",
@@ -3230,14 +3345,14 @@ const ga = {
     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({
+      f({ name: "onPath", plainName: "On the route", technicalName: "onPath", kind: "node", type: "boolean" }),
+      f({ name: "order", plainName: "Position on the route", technicalName: "order", kind: "node", type: "integer" }),
+      f({ name: "distance", plainName: "Distance from the source", technicalName: "distance", kind: "node", type: "number" }),
+      f({ name: "onPath", plainName: "On the route", technicalName: "onPath", kind: "edge", type: "boolean" }),
+      f({ name: "length", plainName: "Nodes on the route", technicalName: "length", kind: "graph", type: "integer" }),
+      f({ name: "cost", plainName: "Total cost", technicalName: "cost", kind: "graph", type: "number" }),
+      f({ name: "hops", plainName: "Edges on the route", technicalName: "hops", kind: "graph", type: "integer" }),
+      f({
         name: "hasNegativeCycle",
         plainName: "Has a loop that costs less every time round",
         technicalName: "hasNegativeCycle",
@@ -3245,10 +3360,10 @@ const ga = {
         type: "boolean"
       })
     ],
-    options: Xe(
-      x(fe),
-      x(ce),
-      Ue(ga)
+    options: et(
+      k(ye),
+      k(le),
+      Ae(Ia)
     ),
     costClass: "instant",
     complexity: "O((n + m) log n) with dijkstra, O(n * m) with bellman-ford",
@@ -3274,9 +3389,9 @@ const ga = {
     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({
+      f({ name: "diameter", plainName: "Widest distance", technicalName: "diameter", kind: "graph", type: "number" }),
+      f({ name: "radius", plainName: "Narrowest distance", technicalName: "radius", kind: "graph", type: "number" }),
+      f({
         name: "hasNegativeCycle",
         plainName: "Has a loop that costs less every time round",
         technicalName: "hasNegativeCycle",
@@ -3284,7 +3399,7 @@ const ga = {
         type: "boolean"
       })
     ],
-    options: x(be),
+    options: k(we),
     costClass: "cubic",
     complexity: "O(n^3)",
     legacyKeys: [{ key: "floyd-warshall" }]
@@ -3297,14 +3412,14 @@ const ga = {
     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" })
+      f({ name: "level", plainName: "Steps away", technicalName: "level", kind: "node", type: "integer" }),
+      f({ name: "levelSize", plainName: "Nodes this many steps away", technicalName: "levelSize", kind: "node", type: "integer" }),
+      f({ name: "order", plainName: "Visit order", technicalName: "order", kind: "node", type: "integer" }),
+      f({ name: "levelCount", plainName: "Levels", technicalName: "levelCount", kind: "graph", type: "integer" }),
+      f({ name: "sizes", plainName: "Level sizes", technicalName: "sizes", kind: "graph", type: "table" }),
+      f({ name: "targetFound", plainName: "Target reached", technicalName: "targetFound", kind: "graph", type: "boolean" })
     ],
-    options: x(de),
+    options: k(he),
     costClass: "instant",
     complexity: "O(n + m)",
     legacyKeys: [{ key: "bfs" }]
@@ -3318,9 +3433,9 @@ const ga = {
     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" })
+      f({ name: "visited", plainName: "Reached", technicalName: "visited", kind: "node", type: "boolean" })
     ],
-    options: x(ge),
+    options: k(fe),
     costClass: "instant",
     complexity: "O(n + m)",
     legacyKeys: [{ key: "dfs" }]
@@ -3332,13 +3447,13 @@ const ga = {
     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", {
+    fields: oe("edge", "In the network", {
       name: "totalWeight",
       plainName: "Total cost",
       technicalName: "totalWeight",
       type: "number"
     }),
-    options: x(ke),
+    options: k(Oe),
     costClass: "instant",
     complexity: "O(m log m)",
     requires: { directed: !1 },
@@ -3351,13 +3466,13 @@ const ga = {
     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", {
+    fields: oe("edge", "In the network", {
       name: "totalWeight",
       plainName: "Total cost",
       technicalName: "totalWeight",
       type: "number"
     }),
-    options: x(ze),
+    options: k(De),
     costClass: "instant",
     complexity: "O(m log n)",
     requires: { directed: !1 },
@@ -3371,16 +3486,16 @@ const ga = {
     category: "structure",
     shape: "edge-set",
     fields: [
-      ...se("edge", "In the pairing", {
+      ...oe("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" })
+      f({ name: "side", plainName: "Side", technicalName: "side", kind: "node", type: "string" }),
+      f({ name: "matched", plainName: "Paired", technicalName: "matched", kind: "node", type: "boolean" })
     ],
-    options: x(he),
+    options: k(ue),
     costClass: "heavy",
     complexity: "O(n * m)",
     requires: { directed: !1 },
@@ -3395,13 +3510,13 @@ const ga = {
     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" })
+      f({ name: "capacity", plainName: "Capacity", technicalName: "capacity", kind: "edge", type: "number" }),
+      f({ name: "utilization", plainName: "Share of capacity used", technicalName: "utilization", kind: "edge", type: "number" }),
+      f({ name: "netFlow", plainName: "Net flow", technicalName: "netFlow", kind: "node", type: "number" }),
+      f({ name: "role", plainName: "Source or sink", technicalName: "role", kind: "node", type: "string" }),
+      f({ name: "maxFlow", plainName: "Most that can flow", technicalName: "maxFlow", kind: "graph", type: "number" })
     ],
-    options: x(Ie),
+    options: k(ze),
     costClass: "heavy",
     complexity: "O(n * m^2)",
     legacyKeys: [{ key: "max-flow" }]
@@ -3414,69 +3529,99 @@ const ga = {
     category: "flow",
     shape: "edge-set",
     fields: [
-      ...se("edge", "In the cut", {
+      ...oe("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" })
+      f({ name: "side", plainName: "Side", technicalName: "side", kind: "node", type: "string" })
     ],
-    options: x(Me),
+    options: k(Te),
     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" }]
+  },
+  {
+    key: "k-core",
+    plainName: "Core depth",
+    technicalName: "K-core decomposition",
+    description: "Peels the graph layer by layer and gives each node the depth of the most tightly knit core it belongs to: a node of depth k has at least k neighbours inside that core.",
+    category: "structure",
+    shape: "node-metric",
+    fields: E("node", { plainName: "Core depth", technicalName: "core number", type: "integer" }),
+    options: k(Se),
+    costClass: "instant",
+    complexity: "O(n + m)",
+    legacyKeys: [{ key: "k-core" }]
+  },
+  {
+    key: "link-prediction",
+    plainName: "Likely new links",
+    technicalName: "Link prediction",
+    description: "Scores the pairs of nodes that are not yet joined by the neighbours they share, and lists the pairs most likely to be joined next.",
+    category: "prediction",
+    shape: "pair-list",
+    fields: [
+      f({ name: "pairs", plainName: "Likely new links", technicalName: "pairs", kind: "graph", type: "table" })
+    ],
+    options: k(Me),
+    costClass: "heavy",
+    complexity: "O(n^2 * d)",
+    legacyKeys: [{ key: "link-prediction" }]
   }
 ];
-function Da(s) {
-  return nt.find((e) => e.key === s);
+function ja(o) {
+  return ot.find((e) => e.key === o);
 }
-function Pa(s) {
-  for (const e of nt)
+function Va(o) {
+  for (const e of ot)
     for (const t of e.legacyKeys)
-      if (t.key === s)
+      if (t.key === o)
         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
+  Te as A,
+  ot as B,
+  st as C,
+  ge as D,
+  be as E,
+  we as F,
+  ve as G,
+  Ne as H,
+  Se as I,
+  Me as J,
+  ke as K,
+  Ce as L,
+  ze as M,
+  Bt as N,
+  Zt as O,
+  Ee as P,
+  Pe as S,
+  it as a,
+  ae as b,
+  ja as c,
+  Va as d,
+  Ka as e,
+  La as f,
+  Ha as g,
+  Wa as h,
+  Fa as i,
+  $a as j,
+  Ua as k,
+  Yt as l,
+  Ga as m,
+  ye as n,
+  de as o,
+  pe as p,
+  Ie as q,
+  xe as r,
+  le as s,
+  Vt as t,
+  he as u,
+  fe as v,
+  me as w,
+  Oe as x,
+  De as y,
+  ue as z
 };