@graphty/graphty-element 2.5.1 → 2.6.0

package/dist/chunks/{algorithms-D-ab-Auu.js → algorithms-BJ6DQMOe.js}

@@ -1,27 +1,27 @@
-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-B9RncoTX.js";
+import { c as ut } from "./common-DWNKjpH_.js";
+import { E as pt, a as mt, N as gt } from "./NodeStyle-CtmA7dXi.js";
+import { J as ft, k as yt, a as E, K as R, h as S, M as ie, P as rt, f as C, A as v, Y as bt, N as wt, Q as vt, S as Nt, n as U, L as et, s as Ze, e as oe, m as Be, i as Ae, o as Qe } from "./optionsFromZod-CKMYSwTz.js";
 import { z as c } from "zod/v4";
-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 "./pluginRegistry-Bs8bEkz9.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;
+import { bellmanFord as kt, betweennessCentrality as St, breadthFirstSearch as Ot, bipartitePartition as xt, maximumBipartiteMatching as It, closenessCentrality as Ct, depthFirstSearch as Tt, eigenvectorCentrality as zt, ConvergenceError as Et, floydWarshall as Mt, girvanNewman as Dt, hits as Pt, katzCentrality as Rt, kCoreDecomposition as $t, labelPropagation as Ft, leiden as Gt, commonNeighborsPrediction as Ht, adamicAdarPrediction as Wt, louvain as Kt, Graph as _e, fordFulkerson as Lt, kargerMinCut as Ut, stoerWagner as jt, minSTCut as Vt, pageRank as qt, connectedComponents as Bt, primMST as tt, stronglyConnectedComponents as Yt } from "@graphty/algorithms";
+import { G as ct } from "./pluginRegistry-Bs8bEkz9.js";
+import { INVALID_INDEX as L } from "@graphty/graph-format";
+var Va = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function qa(s) {
+  return s && s.__esModule && Object.prototype.hasOwnProperty.call(s, "default") ? s.default : s;
 }
-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;
+const Zt = /^#?(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i;
+function Xe(s) {
+  return Number.isFinite(s) ? Math.max(0, Math.min(255, Math.round(s))) : 0;
 }
-function ie(o) {
-  return o.toString(16).padStart(2, "0");
+function je(s) {
+  return s.toString(16).padStart(2, "0");
 }
-function jt(o) {
-  if (!Ut.test(o))
+function Jt(s) {
+  if (!Zt.test(s))
     return null;
-  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);
+  const e = s.startsWith("#") ? s.slice(1) : s, t = e.length <= 4, n = (i) => {
+    const o = t ? e[i].repeat(2) : e.slice(i * 2, i * 2 + 2);
+    return parseInt(o, 16);
   }, a = e.length === 4 || e.length === 8;
   return {
     r: n(0),
@@ -30,29 +30,29 @@ function jt(o) {
     a: a ? n(3) / 255 : 1
   };
 }
-function Ga(o) {
-  return typeof o != "object" || o === null || !("hex" in o) ? null : o;
+function Ba(s) {
+  return typeof s != "object" || s === null || !("hex" in s) ? null : s;
 }
-function Vt(o) {
-  if (o == null)
+function Xt(s) {
+  if (s == null)
     return null;
-  if (typeof o == "object")
-    return Xe(o);
-  const e = jt(o);
+  if (typeof s == "object")
+    return at(s);
+  const e = Jt(s);
   if (e !== null)
-    return Xe(e);
+    return at(e);
   try {
-    const t = rt(o);
-    return t === void 0 ? null : Vt(t);
+    const t = ut(s);
+    return t === void 0 ? null : Xt(t);
   } catch {
     return null;
   }
 }
-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))}` };
+function at(s) {
+  const e = Xe(s.r), t = Xe(s.g), n = Xe(s.b), a = Number.isFinite(s.a) ? Math.max(0, Math.min(1, s.a)) : 1, i = `#${je(e)}${je(t)}${je(n)}`;
+  return { r: e, g: t, b: n, a, hex: a === 1 ? i : `${i}${je(Math.round(a * 255))}` };
 }
-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 = {
+const Qt = gt.options, At = mt.options, nt = pt.options, _t = "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.", Ve = '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`.', it = "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.", Ue = {
   "node.color": {
     channel: "node.color",
     target: "node",
@@ -75,7 +75,7 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     target: "node",
     plainName: "Node Shape",
     accepts: "enum",
-    values: qt,
+    values: Qt,
     stylePath: "shape.type",
     renderable: !0
   },
@@ -102,7 +102,7 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     accepts: "text",
     stylePath: "tooltip.text",
     renderable: !0,
-    caveat: Qe
+    caveat: it
   },
   "node.tooltipStyle": {
     channel: "node.tooltipStyle",
@@ -111,7 +111,7 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     accepts: "labelStyle",
     stylePath: "tooltip",
     renderable: !0,
-    caveat: Qe
+    caveat: it
   },
   "node.opacity": {
     channel: "node.opacity",
@@ -130,7 +130,7 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     accepts: "color",
     stylePath: "effect.outline.color",
     renderable: !0,
-    caveat: Bt
+    caveat: _t
   },
   "node.glow": {
     channel: "node.glow",
@@ -234,7 +234,7 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     target: "edge",
     plainName: "Arrow Head",
     accepts: "enum",
-    values: Je,
+    values: nt,
     stylePath: "arrowHead.type",
     renderable: !0
   },
@@ -272,7 +272,7 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     accepts: "text",
     stylePath: "arrowHead.text.text",
     renderable: !0,
-    caveat: se
+    caveat: Ve
   },
   "edge.arrowHeadTextStyle": {
     channel: "edge.arrowHeadTextStyle",
@@ -281,14 +281,14 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     accepts: "labelStyle",
     stylePath: "arrowHead.text",
     renderable: !0,
-    caveat: se
+    caveat: Ve
   },
   "edge.arrowTail": {
     channel: "edge.arrowTail",
     target: "edge",
     plainName: "Arrow Tail",
     accepts: "enum",
-    values: Je,
+    values: nt,
     stylePath: "arrowTail.type",
     renderable: !0
   },
@@ -326,7 +326,7 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     accepts: "text",
     stylePath: "arrowTail.text.text",
     renderable: !0,
-    caveat: se
+    caveat: Ve
   },
   "edge.arrowTailTextStyle": {
     channel: "edge.arrowTailTextStyle",
@@ -335,7 +335,7 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     accepts: "labelStyle",
     stylePath: "arrowTail.text",
     renderable: !0,
-    caveat: se
+    caveat: Ve
   },
   "edge.animationSpeed": {
     channel: "edge.animationSpeed",
@@ -362,22 +362,22 @@ const qt = dt.options, At = lt.options, Je = ct.options, Bt = "An outline has a
     stylePath: "label",
     renderable: !0
   }
-}, it = Object.keys(ae);
-it.filter(
-  (o) => ae[o].accepts === "color"
+}, dt = Object.keys(Ue);
+dt.filter(
+  (s) => Ue[s].accepts === "color"
 );
-function Yt(o) {
-  return typeof o == "string" && Object.hasOwn(ae, o);
+function ea(s) {
+  return typeof s == "string" && Object.hasOwn(Ue, s);
 }
-function Ha(o) {
-  return Yt(o) ? ae[o] : void 0;
+function Ya(s) {
+  return ea(s) ? Ue[s] : void 0;
 }
-function Wa(o) {
-  return it.map((e) => ae[e]).filter(
-    (e) => e.target === o
+function Za(s) {
+  return dt.map((e) => Ue[e]).filter(
+    (e) => e.target === s
   );
 }
-const st = Object.freeze([
+const lt = Object.freeze([
   {
     id: "fitToGraph",
     plainName: "Fit to graph",
@@ -414,41 +414,41 @@ const st = Object.freeze([
     options: []
   }
 ]);
-function Ka(o) {
-  return st.find((e) => e.id === o) ?? ht(o)?.descriptor;
+function Ja(s) {
+  return lt.find((e) => e.id === s) ?? ft(s)?.descriptor;
 }
-function La(o) {
-  return [...st, ...ut()].filter(
-    (e) => e.modes.includes(o)
+function Xa(s) {
+  return [...lt, ...yt()].filter(
+    (e) => e.modes.includes(s)
   );
 }
-function Ua(o) {
-  return o;
+function Qa(s) {
+  return s;
 }
-function Zt(o) {
+function ta(s) {
   const e = {};
-  for (const [t, n] of Object.entries(o))
+  for (const [t, n] of Object.entries(s))
     e[t] = n.schema;
   return c.object(e);
 }
-function Xt(o, e) {
-  return Zt(o).parse(e);
+function aa(s, e) {
+  return ta(s).parse(e);
 }
-function T(o, e) {
-  return `${String(o)}:${String(e)}`;
+function P(s, e) {
+  return `${String(s)}:${String(e)}`;
 }
-function ce(o, e, t, n) {
+function Ye(s, e, t, n) {
   const a = String(t);
   if (!n.some((i) => String(i) === a))
-    throw new nt({
+    throw new ct({
       code: "E_OPTION_RANGE",
       source: "run",
-      message: `${o}: the ${e} option names node "${a}", which is not in the graph.`,
-      details: { algorithm: o, option: e, value: t }
+      message: `${s}: the ${e} option names node "${a}", which is not in the graph.`,
+      details: { algorithm: s, option: e, value: t }
     });
   return a;
 }
-const Jt = {
+const na = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -463,7 +463,7 @@ const Jt = {
       description: "Destination node for shortest path (uses last node if not set)"
     }
   }
-}, W = class W extends z {
+}, V = class V extends E {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -489,46 +489,46 @@ const Jt = {
    * @returns The route, or null when there are no nodes to search.
    */
   async compute(e) {
-    const t = this.graph.getDataManager(), n = Array.from(t.nodes.keys());
+    const t = this.input("undirected"), n = R(t);
     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], s = this.algorithmGraph("undirected");
+    const a = this.legacyOptions?.source ?? this._schemaOptions.source ?? n[0], i = this.legacyOptions?.target ?? this._schemaOptions.target ?? n[n.length - 1], o = this.algorithmGraph("undirected");
     e.report({ phase: "Relaxing edges", total: null });
-    const r = 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 r = kt(o, a), d = this.reconstructPath(r.predecessors, a, i), h = /* @__PURE__ */ new Map();
+    d.forEach((f, M) => h.set(f, M));
+    for (const f of r.distances.values())
       ;
-    const m = [];
-    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 u = [];
+    await S(e, "Marking the route", n, (f) => {
+      const M = h.get(f), b = r.distances.get(f) ?? 1 / 0;
+      u.push({ id: f, values: { onPath: M !== void 0, order: M, distance: b } });
     });
-    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 l = this.getPathEdges(d), p = [];
+    await S(e, "Marking the route", ie(t), (f) => {
+      const M = P(f.source, f.target), b = P(f.target, f.source);
+      p.push({ id: f.id, values: { onPath: l.has(M) || l.has(b) } });
     });
-    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."), {
+    const m = [`Route from ${String(a)} to ${String(i)}.`];
+    return r.hasNegativeCycle && m.push("A loop that costs less every time round was found, so no distance past it is meaningful."), {
       shape: "path",
       fields: [
-        ...tt,
+        ...rt,
         { name: "distance", kind: "node", type: "number" },
         { name: "hasNegativeCycle", kind: "graph", type: "boolean" }
       ],
-      nodes: m,
+      nodes: u,
       edges: p,
       graph: {
-        length: l.length,
-        cost: l.length > 0 ? r.distances.get(i) ?? 0 : 0,
-        hops: Math.max(l.length - 1, 0),
+        length: d.length,
+        cost: d.length > 0 ? r.distances.get(i) ?? 0 : 0,
+        hops: Math.max(d.length - 1, 0),
         hasNegativeCycle: r.hasNegativeCycle
       },
-      caveats: M({
+      caveats: C({
         method: "bellman-ford",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "distance" },
-        notes: u
+        notes: m
       })
     };
   }
@@ -554,11 +554,11 @@ const Jt = {
   getPathEdges(e) {
     const t = /* @__PURE__ */ new Set();
     for (let n = 0; n < e.length - 1; n++)
-      t.add(T(e[n], e[n + 1]));
+      t.add(P(e[n], e[n + 1]));
     return t;
   }
 };
-W.namespace = "graphty", W.type = "bellman-ford", W.zodOptionsSchema = Jt, W.optionsSchema = {
+V.namespace = "graphty", V.type = "bellman-ford", V.scopeInput = "subgraph", V.zodOptionsSchema = na, V.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 le = W;
-v.register(le);
-const Qt = 2048;
-function _t(o) {
+let ye = V;
+v.register(ye);
+const ia = 2048;
+function sa(s) {
   return {
-    runId: o,
+    runId: s,
     signal: new AbortController().signal,
     report: () => {
     },
@@ -588,14 +588,14 @@ function _t(o) {
     })
   };
 }
-async function D(o, e, t, n) {
-  const a = o.length;
+async function W(s, e, t, n) {
+  const a = s.length;
   let 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()));
+  for (let o = 0; o < a; o++)
+    e.signal.throwIfAborted(), n(s[o], o), (o + 1) % ia === 0 && o + 1 < a && (e.report({ phase: t, completed: o + 1, total: a }), performance.now() - i >= bt && (await e.yieldNow(), i = performance.now()));
   e.report({ phase: t, completed: a, total: a });
 }
-class G extends v {
+class j 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 v {
    * @returns A promise that settles once the result has been published.
    */
   async run() {
-    await this.measureRun(_t(this.type));
+    await this.measureRun(sa(this.type));
   }
   /**
    * Measure the graph on behalf of a run, and hand the result back.
@@ -639,36 +639,38 @@ class G extends v {
    *   `DOMException` named `AbortError`.
    */
   async measureRun(e) {
-    const t = this.graph.getDataManager(), n = Array.from(t.nodes.keys());
+    const t = this.input("declared"), n = R(t);
     if (n.length === 0)
       return;
-    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(),
-      measured: { nodes: n.length, edges: t.edges.size },
-      // The only graph-level field a metric publishes itself. Everything else the shape
-      // promises -- the range, the average, how many elements were measured, how many sit at
-      // the bottom -- is computed from the column the measurement produced.
-      graph: { normalization: i.normalization },
-      nodes: i.nodes,
-      caveats: i.caveats,
-      durationMs: Date.now() - a
-    });
+    const a = Date.now(), i = await this.measure(e, n), o = wt(this.graph), r = vt(
+      Nt(this, {
+        ...o === void 0 ? {} : { labelOf: o },
+        runId: e.runId,
+        shape: "node-metric",
+        fields: this.resultFields(),
+        measured: { nodes: t.nodeCount, edges: t.edgeCount },
+        // The only graph-level field a metric publishes itself. Everything else the shape
+        // promises -- the range, the average, how many elements were measured, how many sit at
+        // the bottom -- is computed from the column the measurement produced.
+        graph: { normalization: i.normalization },
+        nodes: i.nodes,
+        caveats: i.caveats,
+        durationMs: Date.now() - a
+      })
+    );
     return this.#e = r, r;
   }
 }
-const ea = $({
+const oa = U({
   plainName: "Bridging",
   technicalName: "betweenness"
-}), Re = class Re extends G {
+}), ce = class ce extends j {
   /**
    * The fields a betweenness result publishes.
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return ea;
+    return oa;
   }
   /**
    * Score every node by the shortest paths that run through it.
@@ -684,12 +686,12 @@ const ea = $({
       total: t.length,
       message: "Brandes runs a breadth-first search from every node."
     });
-    const a = yt(n);
+    const a = St(n);
     e.signal.throwIfAborted();
     const i = [];
-    return await D(t, e, "reading scores", (s) => {
-      const r = a[String(s)];
-      i.push({ id: s, values: r === void 0 ? {} : { value: r } });
+    return await W(t, e, "reading scores", (o) => {
+      const r = a[String(o)];
+      i.push({ id: o, values: r === void 0 ? {} : { value: r } });
     }), {
       nodes: i,
       // Raw counts. `options.normalized` is not set, so nothing rescales them.
@@ -709,10 +711,10 @@ const ea = $({
     };
   }
 };
-Re.namespace = "graphty", Re.type = "betweenness";
-let de = Re;
-v.register(de);
-const ta = {
+ce.namespace = "graphty", ce.type = "betweenness", ce.scopeInput = "subgraph";
+let be = ce;
+v.register(be);
+const ra = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -728,7 +730,7 @@ const ta = {
       advanced: !0
     }
   }
-}, K = class K extends z {
+}, q = class q extends E {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -754,34 +756,31 @@ const ta = {
    * @returns The layered result, or null when there is nothing to walk.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    const t = R(this.input("undirected"));
     if (t.length === 0)
       return null;
-    const n = this._schemaOptions.targetNode ?? void 0, a = this.graph.getDataManager().getSnapshot();
-    if (a.nodeCount === 0)
-      return null;
-    const i = this.legacyOptions?.source ?? this._schemaOptions.source ?? a.ids.idOf(0);
+    const n = this._schemaOptions.targetNode ?? void 0, a = this.legacyOptions?.source ?? this._schemaOptions.source ?? t[0];
     if (n !== void 0)
-      return this.legacyWalk(e, t, i, n);
-    const { snapshot: s, run: r } = this.accelerated("breadthFirstSearch", "undirected"), l = this.nodeIndex(s, "source", i);
+      return this.legacyWalk(e, t, a, n);
+    const { snapshot: i, run: o } = this.accelerated("breadthFirstSearch", "undirected"), r = this.nodeIndex(i, "source", a);
     e.report({ phase: "Walking outwards", total: null });
-    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) } });
+    const { value: d, precision: h } = await o((p, m) => p.breadthFirstSearch(m, r)), u = /* @__PURE__ */ new Map();
+    for (let p = 0; p < d.visitedCount; p++)
+      u.set(d.order[p], p);
+    const l = [];
+    return await S(e, "Recording levels", t, (p) => {
+      const m = i.ids.indexOf(p), f = m === L ? L : d.depth[m];
+      f !== L && l.push({ id: p, values: { level: f, order: u.get(m) } });
     }), {
       shape: "layered-grouping",
-      fields: [...Ze, { name: "order", kind: "node", type: "integer" }],
-      nodes: p,
-      caveats: M({
+      fields: [...et, { name: "order", kind: "node", type: "integer" }],
+      nodes: l,
+      caveats: C({
         method: "bfs",
         direction: "undirected",
         weight: null,
-        precision: m,
-        notes: [`Walked outwards from ${String(i)}, which is level 0.`]
+        precision: h,
+        notes: [`Walked outwards from ${String(a)}, which is level 0.`]
       })
     };
   }
@@ -797,28 +796,28 @@ const ta = {
     const i = this.algorithmGraph("undirected");
     if (!i.hasNode(n))
       return null;
-    const s = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
-    let l = !1;
-    e.report({ phase: "Walking outwards", total: null }), bt(i, n, {
+    const o = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+    let d = !1;
+    e.report({ phase: "Walking outwards", total: null }), Ot(i, n, {
       targetNode: a,
-      visitCallback: (d, p) => {
-        s.set(d, p), r.set(d, r.size), d === a && (l = !0);
+      visitCallback: (l, p) => {
+        o.set(l, p), r.set(l, r.size), l === a && (d = !0);
       }
     });
     const h = [];
-    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) } });
+    return await S(e, "Recording levels", t, (l) => {
+      const p = o.get(l);
+      p !== void 0 && h.push({ id: l, values: { level: p, order: r.get(l) } });
     }), {
       shape: "layered-grouping",
       fields: [
-        ...Ze,
+        ...et,
         { name: "order", kind: "node", type: "integer" },
         { name: "targetFound", kind: "graph", type: "boolean" }
       ],
       nodes: h,
-      graph: { targetFound: l },
-      caveats: M({
+      graph: { targetFound: d },
+      caveats: C({
         method: "bfs",
         direction: "undirected",
         weight: null,
@@ -830,7 +829,7 @@ const ta = {
     };
   }
 };
-K.namespace = "graphty", K.type = "bfs", K.zodOptionsSchema = ta, K.optionsSchema = {
+q.namespace = "graphty", q.type = "bfs", q.scopeInput = "subgraph", q.zodOptionsSchema = ra, q.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -847,9 +846,9 @@ K.namespace = "graphty", K.type = "bfs", K.zodOptionsSchema = ta, K.optionsSchem
     advanced: !0
   }
 };
-let he = K;
-v.register(he);
-const Fe = class Fe extends z {
+let we = q;
+v.register(we);
+const de = class de extends E {
   /**
    * Pair up the two sides of a two-sided graph so that as many nodes as possible get a partner.
    *
@@ -861,26 +860,26 @@ const Fe = class Fe extends z {
    * @returns The edge set, or null when there are no edges to pair.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().edges.values());
+    const t = ie(this.input("undirected"));
     if (t.length === 0)
       return null;
     const n = this.algorithmGraph("undirected"), a = [
-      ...je("edge", { name: "bipartite", type: "boolean" }),
+      ...Ze("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 = wt(n);
+    const i = xt(n);
     if (i === null) {
-      const d = [];
+      const l = [];
       return await S(e, "Marking the pairing", t, (p) => {
-        d.push({ id: p.id, values: { in: !1 } });
+        l.push({ id: p.id, values: { in: !1 } });
       }), {
         shape: "edge-set",
         fields: a,
-        edges: d,
+        edges: l,
         graph: { bipartite: !1 },
-        caveats: M({
+        caveats: C({
           method: "bipartite-matching",
           direction: "undirected",
           weight: null,
@@ -889,49 +888,49 @@ const Fe = class Fe extends z {
       };
     }
     e.report({ phase: "Pairing nodes", total: null });
-    const s = vt(n, {
+    const o = It(n, {
       leftNodes: i.left,
       rightNodes: i.right
     }), r = /* @__PURE__ */ new Set();
-    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)) } });
+    for (const [l, p] of o.matching)
+      r.add(P(l, p)), r.add(P(p, l));
+    const d = [];
+    await S(e, "Marking the pairing", t, (l) => {
+      d.push({ id: l.id, values: { in: r.has(P(l.source, l.target)) } });
     });
-    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) } });
+    const h = new Set(o.matching.values()), u = [];
+    return await S(e, "Marking sides", Array.from(i.left), (l) => {
+      u.push({ id: l, values: { side: "left", matched: o.matching.has(l) } });
+    }), await S(e, "Marking sides", Array.from(i.right), (l) => {
+      u.push({ id: l, values: { side: "right", matched: h.has(l) } });
     }), {
       shape: "edge-set",
       fields: a,
-      nodes: m,
-      edges: l,
+      nodes: u,
+      edges: d,
       graph: { bipartite: !0 },
-      caveats: M({
+      caveats: C({
         method: "bipartite-matching",
         direction: "undirected",
         weight: null,
-        notes: [`${String(s.size)} of the two sides' nodes found a partner.`]
+        notes: [`${String(o.size)} of the two sides' nodes found a partner.`]
       })
     };
   }
 };
-Fe.namespace = "graphty", Fe.type = "bipartite-matching";
-let ue = Fe;
-v.register(ue);
-const aa = $({
+de.namespace = "graphty", de.type = "bipartite-matching", de.scopeInput = "subgraph";
+let ve = de;
+v.register(ve);
+const ca = U({
   plainName: "Reach",
   technicalName: "closeness"
-}), $e = class $e extends G {
+}), le = class le extends j {
   /**
    * The fields a closeness result publishes.
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return aa;
+    return ca;
   }
   /**
    * Score every node by how short its paths to the rest of the graph are.
@@ -947,12 +946,12 @@ const aa = $({
       total: t.length,
       message: "A breadth-first search runs from every node."
     });
-    const a = Nt(n);
+    const a = Ct(n);
     e.signal.throwIfAborted();
     const i = [];
-    return await D(t, e, "reading scores", (s) => {
-      const r = a[String(s)];
-      i.push({ id: s, values: r === void 0 ? {} : { value: r } });
+    return await W(t, e, "reading scores", (o) => {
+      const r = a[String(o)];
+      i.push({ id: o, values: r === void 0 ? {} : { value: r } });
     }), {
       nodes: i,
       // The algorithm's own figure, published as it was computed.
@@ -972,10 +971,10 @@ const aa = $({
     };
   }
 };
-$e.namespace = "graphty", $e.type = "closeness";
-let pe = $e;
-v.register(pe);
-const Ge = class Ge extends z {
+le.namespace = "graphty", le.type = "closeness", le.scopeInput = "subgraph";
+let Ne = le;
+v.register(Ne);
+const he = class he extends E {
   /**
    * Find the separate pieces of the graph.
    *
@@ -986,20 +985,20 @@ const Ge = class Ge extends z {
    * @returns The community result, or null when there are no nodes to group.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    const t = R(this.input("undirected"));
     if (t.length === 0)
       return null;
     const { snapshot: n, run: a } = this.accelerated("connectedComponents", "undirected"), { ids: i } = n;
     e.report({ phase: "Finding pieces", total: null });
-    const { value: s, precision: r } = await a((h, m) => h.connectedComponents(m)), l = [];
+    const { value: o, precision: r } = await a((h, u) => h.connectedComponents(u)), d = [];
     return await S(e, "Grouping nodes", t, (h) => {
-      const m = i.indexOf(h);
-      l.push({ id: h, values: { group: s.labels[m] ?? 0 } });
+      const u = i.indexOf(h);
+      d.push({ id: h, values: { group: o.labels[u] ?? 0 } });
     }), {
       shape: "community",
-      fields: ee(!1),
-      nodes: l,
-      caveats: M({
+      fields: oe(!1),
+      nodes: d,
+      caveats: C({
         method: "connected-components",
         direction: "undirected",
         weight: null,
@@ -1009,32 +1008,32 @@ const Ge = class Ge extends z {
     };
   }
 };
-Ge.namespace = "graphty", Ge.type = "connected-components";
-let me = Ge;
-v.register(me);
-const na = [
-  ...$({ plainName: "Connections", technicalName: "degree", type: "integer", unit: "links" }),
-  re({
+he.namespace = "graphty", he.type = "connected-components", he.scopeInput = "subgraph";
+let ke = he;
+v.register(ke);
+const da = [
+  ...U({ plainName: "Connections", technicalName: "degree", type: "integer", unit: "links" }),
+  Be({
     name: "inDegree",
     plainName: "Incoming connections",
     technicalName: "inDegree",
     kind: "node",
     type: "integer"
   }),
-  re({
+  Be({
     name: "outDegree",
     plainName: "Outgoing connections",
     technicalName: "outDegree",
     kind: "node",
     type: "integer"
   })
-], He = class He extends G {
+], ue = class ue extends j {
   /**
    * The fields a degree result publishes.
    * @returns The uniform node-metric fields, plus `inDegree` and `outDegree`.
    */
   resultFields() {
-    return na;
+    return da;
   }
   /**
    * Count every node's edges.
@@ -1044,9 +1043,9 @@ const na = [
    */
   async measure(e, t) {
     const n = this.algorithmGraph("directed"), a = [];
-    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 } });
+    return await W(t, e, "counting connections", (i) => {
+      const o = n.inDegree(i), r = n.outDegree(i);
+      a.push({ id: i, values: { value: o + r, inDegree: o, outDegree: r } });
     }), {
       nodes: a,
       // A count of edges, published as it was counted.
@@ -1057,15 +1056,17 @@ const na = [
         weight: null,
         precision: "f64",
         method: "degree",
-        notes: ["Counted over the graph as the records declared it, so a node's total is its incoming edges plus its outgoing ones."]
+        notes: [
+          "Counted over the graph as the records declared it, so a node's total is its incoming edges plus its outgoing ones."
+        ]
       }
     };
   }
 };
-He.namespace = "graphty", He.type = "degree";
-let ge = He;
-v.register(ge);
-const ia = {
+ue.namespace = "graphty", ue.type = "degree", ue.scopeInput = "subgraph";
+let Se = ue;
+v.register(Se);
+const la = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -1097,7 +1098,7 @@ const ia = {
       advanced: !0
     }
   }
-}, L = class L extends z {
+}, B = class B extends E {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -1122,38 +1123,40 @@ const ia = {
    * @returns The exploration order, or null when there is nothing to walk.
    */
   async compute(e) {
-    const t = this.graph.getDataManager(), n = Array.from(t.nodes.keys());
-    if (n.length === 0)
+    const t = R(this.input("undirected"));
+    if (t.length === 0)
       return null;
-    const a = this.legacyOptions?.source ?? this._schemaOptions.source ?? n[0], { targetNode: i, recursive: s, preOrder: r } = this._schemaOptions;
-    if (!t.nodes.has(a))
+    const n = this.legacyOptions?.source ?? this._schemaOptions.source ?? t[0], { targetNode: a, recursive: i, preOrder: o } = this._schemaOptions;
+    if (!t.includes(n))
       return null;
-    const l = this.algorithmGraph("undirected");
+    const r = this.algorithmGraph("undirected");
     e.report({ phase: "Walking deep", total: null });
-    const h = kt(l, a, {
-      targetNode: i ?? void 0,
-      recursive: s,
-      preOrder: r
-    }), m = /* @__PURE__ */ new Map();
-    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) } });
+    const d = Tt(r, n, {
+      targetNode: a ?? void 0,
+      recursive: i,
+      preOrder: o
+    }), h = /* @__PURE__ */ new Map();
+    d.order.forEach((l, p) => h.set(l, p));
+    const u = [];
+    return await S(e, "Recording the order", t, (l) => {
+      const p = h.get(l);
+      u.push({ id: l, values: { value: p, visited: d.visited.has(l) } });
     }), {
       shape: "node-metric",
-      fields: [...Be("node", "integer"), { name: "visited", kind: "node", type: "boolean" }],
-      nodes: d,
-      caveats: M({
+      fields: [...Ae("node", "integer"), { name: "visited", kind: "node", type: "boolean" }],
+      nodes: u,
+      caveats: C({
         method: "dfs",
         direction: "undirected",
         weight: null,
-        notes: [`Walked from ${String(a)}, ${r ? "recording each node as it was reached" : "recording each node as it was left"}.`]
+        notes: [
+          `Walked from ${String(n)}, ${o ? "recording each node as it was reached" : "recording each node as it was left"}.`
+        ]
       })
     };
   }
 };
-L.namespace = "graphty", L.type = "dfs", L.zodOptionsSchema = ia, L.optionsSchema = {
+B.namespace = "graphty", B.type = "dfs", B.scopeInput = "subgraph", B.zodOptionsSchema = la, B.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -1184,9 +1187,9 @@ L.namespace = "graphty", L.type = "dfs", L.zodOptionsSchema = ia, L.optionsSchem
     advanced: !0
   }
 };
-let fe = L;
-v.register(fe);
-const sa = {
+let Oe = B;
+v.register(Oe);
+const ha = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -1209,7 +1212,7 @@ const sa = {
       advanced: !0
     }
   }
-}, U = class U extends z {
+}, K = class K extends E {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -1235,53 +1238,57 @@ const sa = {
    * @returns The route, or null when there are no nodes to search.
    */
   async compute(e) {
-    const t = this.graph.getDataManager(), n = Array.from(t.nodes.keys());
+    const t = this.input("undirected"), n = R(t);
     if (n.length === 0)
       return null;
-    const { snapshot: a, edgeRemap: i, run: s } = this.accelerated("sssp", "undirected");
-    if (a.nodeCount === 0)
-      return null;
-    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);
+    const { snapshot: a, edgeRemap: i, run: o } = this.accelerated("sssp", "undirected"), { 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), u = this.nodeIndex(a, "source", d), l = this.nodeIndex(a, "target", h);
     e.report({ phase: "Searching for the route", total: null });
-    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,
+    const { value: p, precision: m } = await o((N, z) => N.sssp(z, u)), f = p.pathTo(l), M = new Set(p.pathEdges(l)), b = /* @__PURE__ */ new Map();
+    f.forEach((N, z) => b.set(N, z));
+    const w = [];
+    await S(e, "Marking the route", n, (N) => {
+      const z = r.indexOf(N), y = z === L ? void 0 : b.get(z);
+      w.push({
+        id: N,
         values: {
-          onPath: b !== void 0,
-          order: b,
-          distance: N === F ? 1 / 0 : p.dist[N]
+          onPath: y !== void 0,
+          order: y,
+          distance: z === L ? 1 / 0 : p.dist[z]
         }
       });
     });
-    const I = [];
-    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) } });
+    const O = ie(t), { src: I, weights: x } = t.graph.edgeList(), T = /* @__PURE__ */ new Map();
+    for (const N of O) {
+      const z = i === null ? N.row : i[N.row] ?? L;
+      if (!M.has(z))
+        continue;
+      const y = t.graph.directed ? `${String(z)}>${String(I[N.row])}` : String(z), $ = x === null ? 1 : x[N.row], se = T.get(y);
+      (se === void 0 || $ < se.weight) && T.set(y, { row: N.row, weight: $ });
+    }
+    const F = new Set([...T.values()].map((N) => N.row)), D = [];
+    return await S(e, "Marking the route", O, (N) => {
+      D.push({ id: N.id, values: { onPath: F.has(N.row) } });
     }), {
       shape: "path",
-      fields: [...tt, { name: "distance", kind: "node", type: "number" }],
-      nodes: O,
-      edges: I,
+      fields: [...rt, { name: "distance", kind: "node", type: "number" }],
+      nodes: w,
+      edges: D,
       graph: {
-        length: g.length,
-        cost: g.length === 0 ? 0 : p.dist[d],
-        hops: Math.max(g.length - 1, 0)
+        length: f.length,
+        cost: f.length === 0 ? 0 : p.dist[l],
+        hops: Math.max(f.length - 1, 0)
       },
-      caveats: M({
+      caveats: C({
         method: "dijkstra",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "distance" },
-        precision: u,
-        notes: g.length === 0 ? [`No route runs from ${String(l)} to ${String(h)}.`] : [`Route from ${String(l)} to ${String(h)}.`]
+        precision: m,
+        notes: f.length === 0 ? [`No route runs from ${String(d)} to ${String(h)}.`] : [`Route from ${String(d)} to ${String(h)}.`]
       })
     };
   }
 };
-U.namespace = "graphty", U.type = "dijkstra", U.zodOptionsSchema = sa, U.optionsSchema = {
+K.namespace = "graphty", K.type = "dijkstra", K.scopeInput = "subgraph", K.parallelEdges = "min", K.zodOptionsSchema = ha, K.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -1304,9 +1311,9 @@ U.namespace = "graphty", U.type = "dijkstra", U.zodOptionsSchema = sa, U.options
     advanced: !0
   }
 };
-let ye = U;
-v.register(ye);
-const oa = {
+let xe = K;
+v.register(xe);
+const ua = {
   maxIterations: {
     schema: c.number().int().min(1).max(1e4).default(1e3),
     meta: {
@@ -1347,16 +1354,16 @@ const oa = {
       advanced: !0
     }
   }
-}, ra = $({
+}, pa = U({
   plainName: "Influence by association",
   technicalName: "eigenvector score"
-}), R = class R extends G {
+}), H = class H extends j {
   /**
    * The fields an eigenvector result publishes.
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return ra;
+    return pa;
   }
   /**
    * Score every node by the influence of its neighbours.
@@ -1365,41 +1372,41 @@ const oa = {
    * @returns One score per node, scaled as the options asked for.
    */
   async measure(e, t) {
-    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");
+    const { maxIterations: n, tolerance: a, normalized: i, mode: o, endpoints: r } = this.schemaOptions, d = this._schemaOptions.startVector ?? void 0, h = o !== "total" && this.input("declared").graph.directed, u = this.algorithmGraph(h ? "directed" : "undirected");
     e.report({
       phase: "iterating",
       completed: 0,
       total: t.length,
       message: `Power iteration, up to ${String(n)} passes.`
     });
-    let d;
+    let l;
     try {
-      d = St(m, {
+      l = zt(u, {
         normalized: i,
         maxIterations: n,
         tolerance: a,
-        mode: s,
+        mode: o,
         endpoints: r,
-        startVector: l
+        startVector: d
       });
-    } catch (u) {
-      if (!(u instanceof Ot))
-        throw u;
-      const g = `${R.namespace}:${R.type}`;
-      throw new nt({
+    } catch (m) {
+      if (!(m instanceof Et))
+        throw m;
+      const f = `${H.namespace}:${H.type}`;
+      throw new ct({
         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: g, maxIterations: n, tolerance: a },
-        cause: u
+        details: { algorithm: f, maxIterations: n, tolerance: a },
+        cause: m
       });
     }
     e.signal.throwIfAborted();
     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 } });
+    return await W(t, e, "reading scores", (m) => {
+      const f = l[String(m)];
+      p.push({ id: m, values: f === void 0 ? {} : { value: f } });
     }), {
       nodes: p,
       // With `normalized`, the algorithm rescales its eigenvector so the lowest score is 0
@@ -1417,7 +1424,7 @@ const oa = {
         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."
+            o === "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."
         ]
@@ -1425,7 +1432,7 @@ const oa = {
     };
   }
 };
-R.namespace = "graphty", R.type = "eigenvector", R.zodOptionsSchema = oa, R.optionsSchema = {
+H.namespace = "graphty", H.type = "eigenvector", H.scopeInput = "subgraph", H.zodOptionsSchema = ua, H.optionsSchema = {
   maxIterations: {
     type: "integer",
     default: 1e3,
@@ -1472,9 +1479,9 @@ R.namespace = "graphty", R.type = "eigenvector", R.zodOptionsSchema = oa, R.opti
   }
   // Note: startVector is a Map type - programmatic only, not in schema
 };
-let be = R;
-v.register(be);
-const We = class We extends z {
+let Ie = H;
+v.register(Ie);
+const pe = class pe extends E {
   /**
    * Measure the distance between every pair of nodes, and give each node the distance to the
    * node furthest from it.
@@ -1493,42 +1500,42 @@ const We = class We extends z {
    * @returns The all-pairs measurement, or null when there are no nodes to measure.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    const t = R(this.input("undirected"));
     if (t.length === 0)
       return null;
     const n = this.algorithmGraph("undirected");
     e.report({ phase: "Measuring every pair", total: null });
-    const a = xt(n), i = /* @__PURE__ */ new Map();
+    const a = Mt(n), i = /* @__PURE__ */ new Map();
     await S(e, "Measuring reach", t, (h) => {
-      const m = a.distances.get(h);
-      if (m === void 0) {
+      const u = a.distances.get(h);
+      if (u === void 0) {
         i.set(h, 1 / 0);
         return;
       }
-      let d = 0;
-      for (const p of m.values())
-        isFinite(p) && p > d && (d = p);
-      i.set(h, d);
+      let l = 0;
+      for (const p of u.values())
+        isFinite(p) && p > l && (l = p);
+      i.set(h, l);
     });
-    let s = 0, r = 1 / 0;
+    let o = 0, r = 1 / 0;
     for (const h of i.values())
-      isFinite(h) && (s = Math.max(s, h), r = Math.min(r, h));
+      isFinite(h) && (o = Math.max(o, h), r = Math.min(r, h));
     r === 1 / 0 && (r = 0);
-    const l = [];
+    const d = [];
     return await S(e, "Publishing distances", t, (h) => {
-      const m = i.get(h) ?? 1 / 0;
-      isFinite(m) && l.push({ id: h, values: { value: m } });
+      const u = i.get(h) ?? 1 / 0;
+      isFinite(u) && d.push({ id: h, values: { value: u } });
     }), {
       shape: "node-metric",
       fields: [
-        ...Be("node"),
+        ...Ae("node"),
         { name: "diameter", kind: "graph", type: "number" },
         { name: "radius", kind: "graph", type: "number" },
         { name: "hasNegativeCycle", kind: "graph", type: "boolean" }
       ],
-      nodes: l,
-      graph: { diameter: s, radius: r, hasNegativeCycle: a.hasNegativeCycle },
-      caveats: M({
+      nodes: d,
+      graph: { diameter: o, radius: r, hasNegativeCycle: a.hasNegativeCycle },
+      caveats: C({
         method: "floyd-warshall",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "distance" },
@@ -1539,10 +1546,10 @@ const We = class We extends z {
     };
   }
 };
-We.namespace = "graphty", We.type = "floyd-warshall";
-let we = We;
-v.register(we);
-const ca = {
+pe.namespace = "graphty", pe.type = "floyd-warshall", pe.scopeInput = "subgraph";
+let Ce = pe;
+v.register(Ce);
+const ma = {
   maxCommunities: {
     schema: c.number().int().min(0).max(100).default(0),
     meta: {
@@ -1566,7 +1573,7 @@ const ca = {
       advanced: !0
     }
   }
-}, j = class j extends z {
+}, Y = class Y extends E {
   /**
    * Group the nodes into communities by cutting the edges the most routes run through.
    *
@@ -1577,43 +1584,43 @@ const ca = {
    * @returns The community result, or null when there are no nodes to group.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    const t = R(this.input("undirected"));
     if (t.length === 0)
       return null;
-    const { maxCommunities: n, minCommunitySize: a, maxIterations: i } = this.schemaOptions, s = this.algorithmGraph("undirected");
+    const { maxCommunities: n, minCommunitySize: a, maxIterations: i } = this.schemaOptions, o = this.algorithmGraph("undirected");
     e.report({ phase: "Cutting bridges", total: null });
-    const r = It(s, {
+    const r = Dt(o, {
       maxCommunities: n > 0 ? n : void 0,
       minCommunitySize: a,
       maxIterations: i
-    }), 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,
+    }), d = n > 0 ? r.filter((m) => m.communities.length <= n) : r, u = (d.length > 0 ? d : r.slice(0, 1)).reduce(
+      (m, f) => m === void 0 || f.modularity > m.modularity ? f : m,
       void 0
-    ), d = /* @__PURE__ */ new Map();
-    if (m !== void 0)
-      for (let u = 0; u < m.communities.length; u++)
-        for (const g of m.communities[u])
-          d.set(g, u);
+    ), l = /* @__PURE__ */ new Map();
+    if (u !== void 0)
+      for (let m = 0; m < u.communities.length; m++)
+        for (const f of u.communities[m])
+          l.set(f, m);
     else
-      t.forEach((u, g) => d.set(u, g));
+      t.forEach((m, f) => l.set(m, f));
     const p = [];
-    return await S(e, "Grouping nodes", t, (u) => {
-      p.push({ id: u, values: { group: d.get(u) ?? 0 } });
+    return await S(e, "Grouping nodes", t, (m) => {
+      p.push({ id: m, values: { group: l.get(m) ?? 0 } });
     }), {
       shape: "community",
-      fields: ee(!0),
+      fields: oe(!0),
       nodes: p,
-      graph: { modularity: m?.modularity ?? 0 },
-      caveats: M({
+      graph: { modularity: u?.modularity ?? 0 },
+      caveats: C({
         method: "girvan-newman",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "strength" },
-        notes: m === void 0 ? ["No edge could be cut, so every node is its own community."] : [`Kept the best of ${String(r.length)} successive cuts.`]
+        notes: u === void 0 ? ["No edge could be cut, so every node is its own community."] : [`Kept the best of ${String(r.length)} successive cuts.`]
       })
     };
   }
 };
-j.namespace = "graphty", j.type = "girvan-newman", j.zodOptionsSchema = ca, j.optionsSchema = {
+Y.namespace = "graphty", Y.type = "girvan-newman", Y.scopeInput = "subgraph", Y.zodOptionsSchema = ma, Y.optionsSchema = {
   maxCommunities: {
     type: "integer",
     default: 0,
@@ -1641,9 +1648,9 @@ j.namespace = "graphty", j.type = "girvan-newman", j.zodOptionsSchema = ca, j.op
     advanced: !0
   }
 };
-let ve = j;
-v.register(ve);
-const la = {
+let Te = Y;
+v.register(Te);
+const ga = {
   maxIterations: {
     schema: c.number().int().min(1).max(1e3).default(100),
     meta: {
@@ -1684,23 +1691,23 @@ const la = {
       advanced: !0
     }
   }
-}, da = [
-  ...$({ plainName: "Hub and authority", technicalName: "combined HITS score" }),
-  re({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
-  re({
+}, fa = [
+  ...U({ plainName: "Hub and authority", technicalName: "combined HITS score" }),
+  Be({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
+  Be({
     name: "authority",
     plainName: "Authority",
     technicalName: "authority score",
     kind: "node",
     type: "number"
   })
-], V = class V extends G {
+], Z = class Z extends j {
   /**
    * The fields a HITS result publishes.
    * @returns The uniform node-metric fields, plus `hub` and `authority`.
    */
   resultFields() {
-    return da;
+    return fa;
   }
   /**
    * Score every node as a hub and as an authority.
@@ -1709,31 +1716,31 @@ const la = {
    * @returns The combined score per node, with the two halves beside it.
    */
   async measure(e, t) {
-    const { maxIterations: n, tolerance: a, normalized: i, mode: s, endpoints: r } = this.schemaOptions, l = this.algorithmGraph("directed");
+    const { maxIterations: n, tolerance: a, normalized: i, mode: o, endpoints: r } = this.schemaOptions, d = this.algorithmGraph("directed");
     e.report({
       phase: "iterating",
       completed: 0,
       total: t.length,
       message: `Hub and authority scores refine each other, up to ${String(n)} passes.`
     });
-    const h = Mt(l, {
+    const h = Pt(d, {
       maxIterations: n,
       tolerance: a,
       normalized: i,
-      mode: s,
+      mode: o,
       endpoints: r
     });
     e.signal.throwIfAborted();
-    const m = [];
-    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: {} });
+    const u = [];
+    return await W(t, e, "reading scores", (l) => {
+      const p = h.hubs[String(l)], m = h.authorities[String(l)];
+      if (p === void 0 || m === void 0) {
+        u.push({ id: l, values: {} });
         return;
       }
-      m.push({ id: d, values: { value: (p + u) / 2, hub: p, authority: u } });
+      u.push({ id: l, values: { value: (p + m) / 2, hub: p, authority: m } });
     }), {
-      nodes: m,
+      nodes: u,
       // The combined score is the average of two vectors the algorithm scaled, which leaves
       // it scaled by neither of the two rules this field names. The notes say what was done.
       normalization: "none",
@@ -1756,7 +1763,7 @@ const la = {
     };
   }
 };
-V.namespace = "graphty", V.type = "hits", V.zodOptionsSchema = la, V.optionsSchema = {
+Z.namespace = "graphty", Z.type = "hits", Z.scopeInput = "subgraph", Z.zodOptionsSchema = ga, Z.optionsSchema = {
   maxIterations: {
     type: "integer",
     default: 100,
@@ -1802,9 +1809,9 @@ V.namespace = "graphty", V.type = "hits", V.zodOptionsSchema = la, V.optionsSche
     advanced: !0
   }
 };
-let Ne = V;
-v.register(Ne);
-const ha = {
+let ze = Z;
+v.register(ze);
+const ya = {
   alpha: {
     schema: c.number().min(0.01).max(0.5).default(0.1),
     meta: {
@@ -1862,16 +1869,16 @@ const ha = {
       advanced: !0
     }
   }
-}, ua = $({
+}, ba = U({
   plainName: "Influence at a distance",
   technicalName: "Katz score"
-}), q = class q extends G {
+}), J = class J extends j {
   /**
    * The fields a Katz result publishes.
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return ua;
+    return ba;
   }
   /**
    * Score every node by the paths that reach it.
@@ -1880,27 +1887,27 @@ const ha = {
    * @returns One score per node, scaled as the options asked for.
    */
   async measure(e, t) {
-    const { alpha: n, beta: a, maxIterations: i, tolerance: s, normalized: r, mode: l, endpoints: h } = this.schemaOptions, m = this.algorithmGraph("undirected");
+    const { alpha: n, beta: a, maxIterations: i, tolerance: o, normalized: r, mode: d, endpoints: h } = this.schemaOptions, u = this.algorithmGraph("undirected");
     e.report({
       phase: "iterating",
       completed: 0,
       total: t.length,
       message: `Attenuated path sums, up to ${String(i)} passes.`
     });
-    const d = Ct(m, {
+    const l = Rt(u, {
       normalized: r,
       alpha: n,
       beta: a,
       maxIterations: i,
-      tolerance: s,
-      mode: l,
+      tolerance: o,
+      mode: d,
       endpoints: h
     });
     e.signal.throwIfAborted();
     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 } });
+    return await W(t, e, "reading scores", (m) => {
+      const f = l[String(m)];
+      p.push({ id: m, values: f === void 0 ? {} : { value: f } });
     }), {
       nodes: p,
       // With `normalized`, the algorithm rescales so the lowest score is 0 and the highest
@@ -1916,7 +1923,7 @@ const ha = {
         // 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(s)} or after ${String(i)} passes, whichever comes first.`,
+          `Iteration stops at a tolerance of ${String(o)} or after ${String(i)} passes, whichever comes first.`,
           "Whether it reached the tolerance is not reported by the implementation, so this run cannot say whether it converged.",
           "Edge weights are not read."
         ]
@@ -1924,7 +1931,7 @@ const ha = {
     };
   }
 };
-q.namespace = "graphty", q.type = "katz", q.zodOptionsSchema = ha, q.optionsSchema = {
+J.namespace = "graphty", J.type = "katz", J.scopeInput = "subgraph", J.zodOptionsSchema = ya, J.optionsSchema = {
   alpha: {
     type: "number",
     default: 0.1,
@@ -1989,19 +1996,19 @@ q.namespace = "graphty", q.type = "katz", q.zodOptionsSchema = ha, q.optionsSche
     advanced: !0
   }
 };
-let ke = q;
-v.register(ke);
-const pa = $({
+let Ee = J;
+v.register(Ee);
+const wa = U({
   plainName: "Core depth",
   technicalName: "core number",
   type: "integer"
-}), Ke = class Ke extends G {
+}), me = class me extends j {
   /**
    * The fields a k-core result publishes.
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return pa;
+    return wa;
   }
   /**
    * Give every node its core number.
@@ -2012,12 +2019,12 @@ const pa = $({
   async measure(e, t) {
     const n = this.algorithmGraph("undirected");
     e.report({ phase: "peeling cores", total: null });
-    const { coreness: a } = zt(n);
+    const { coreness: a } = $t(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 } });
+    return await W(t, e, "reading core numbers", (o) => {
+      const r = a.get(String(o));
+      i.push({ id: o, values: r === void 0 ? {} : { value: r } });
     }), {
       nodes: i,
       // A count of neighbours, published as it was counted.
@@ -2033,10 +2040,10 @@ const pa = $({
     };
   }
 };
-Ke.namespace = "graphty", Ke.type = "k-core";
-let Se = Ke;
-v.register(Se);
-const Le = class Le extends z {
+me.namespace = "graphty", me.type = "k-core", me.scopeInput = "subgraph";
+let Me = me;
+v.register(Me);
+const ge = class ge extends E {
   /**
    * Find the cheapest set of edges that still joins every node.
    *
@@ -2047,34 +2054,34 @@ const Le = class Le extends z {
    * @returns The edge set, or null when there are no edges to choose from.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().edges.values());
+    const t = ie(this.input("undirected"));
     if (t.length === 0)
       return null;
     const { edgeRemap: n, run: a } = this.accelerated("minimumSpanningTree", "undirected");
     e.report({ phase: "Choosing edges", total: null });
-    const { value: i, precision: s } = await a((h, m) => h.minimumSpanningTree(m)), r = new Set(i.edges), l = [];
+    const { value: i, precision: o } = await a((h, u) => h.minimumSpanningTree(u)), r = new Set(i.edges), d = [];
     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) } });
+      const u = n === null ? h.row : n[h.row] ?? L;
+      d.push({ id: h.id, values: { in: r.has(u) } });
     }), {
       shape: "edge-set",
-      fields: je("edge", { name: "totalWeight", type: "number" }),
-      edges: l,
+      fields: Ze("edge", { name: "totalWeight", type: "number" }),
+      edges: d,
       graph: { totalWeight: i.totalWeight },
-      caveats: M({
+      caveats: C({
         method: "kruskal",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "distance" },
-        precision: s,
+        precision: o,
         notes: [`The tree joins the graph with ${String(i.edges.length)} edges.`]
       })
     };
   }
 };
-Le.namespace = "graphty", Le.type = "kruskal";
-let Oe = Le;
-v.register(Oe);
-const ma = {
+ge.namespace = "graphty", ge.type = "kruskal", ge.scopeInput = "subgraph";
+let De = ge;
+v.register(De);
+const va = {
   maxIterations: {
     schema: c.number().int().min(1).max(500).default(100),
     meta: {
@@ -2090,7 +2097,7 @@ const ma = {
       advanced: !0
     }
   }
-}, A = class A extends z {
+}, X = class X extends E {
   /**
    * Group the nodes into communities by letting labels spread between neighbours.
    *
@@ -2102,34 +2109,34 @@ const ma = {
    * @returns The community result, or null when there are no nodes to group.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    const t = R(this.input("undirected"));
     if (t.length === 0)
       return null;
     const { maxIterations: n, randomSeed: a } = this.schemaOptions, i = this.algorithmGraph("undirected");
     e.report({ phase: "Spreading labels", total: null });
-    const s = Tt(i, {
+    const o = Ft(i, {
       maxIterations: n,
       randomSeed: a
     }), r = [];
-    return await S(e, "Grouping nodes", t, (l) => {
-      r.push({ id: l, values: { group: s.communities.get(String(l)) ?? 0 } });
+    return await S(e, "Grouping nodes", t, (d) => {
+      r.push({ id: d, values: { group: o.communities.get(String(d)) ?? 0 } });
     }), {
       shape: "community",
-      fields: ee(!1),
+      fields: oe(!1),
       nodes: r,
-      caveats: M({
+      caveats: C({
         method: "label-propagation",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "strength" },
-        converged: s.converged,
-        iterations: s.iterations,
+        converged: o.converged,
+        iterations: o.iterations,
         seed: a,
         notes: ["Label propagation does not score its own partition, so it reports no modularity."]
       })
     };
   }
 };
-A.namespace = "graphty", A.type = "label-propagation", A.zodOptionsSchema = ma, A.optionsSchema = {
+X.namespace = "graphty", X.type = "label-propagation", X.scopeInput = "subgraph", X.zodOptionsSchema = va, X.optionsSchema = {
   maxIterations: {
     type: "integer",
     default: 100,
@@ -2148,9 +2155,9 @@ A.namespace = "graphty", A.type = "label-propagation", A.zodOptionsSchema = ma,
     advanced: !0
   }
 };
-let xe = A;
-v.register(xe);
-const ga = {
+let Pe = X;
+v.register(Pe);
+const Na = {
   resolution: {
     schema: c.number().min(0.1).max(5).default(1),
     meta: {
@@ -2183,7 +2190,7 @@ const ga = {
       advanced: !0
     }
   }
-}, B = class B extends z {
+}, Q = class Q extends E {
   /**
    * Group the nodes into communities, refining each group before it is kept.
    *
@@ -2194,35 +2201,35 @@ const ga = {
    * @returns The community result, or null when there are no nodes to group.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    const t = R(this.input("undirected"));
     if (t.length === 0)
       return null;
-    const { resolution: n, randomSeed: a, maxIterations: i, threshold: s } = this.schemaOptions, r = this.algorithmGraph("undirected");
+    const { resolution: n, randomSeed: a, maxIterations: i, threshold: o } = this.schemaOptions, r = this.algorithmGraph("undirected");
     e.report({ phase: "Refining communities", total: null });
-    const l = Et(r, {
+    const d = Gt(r, {
       resolution: n,
       randomSeed: a,
       maxIterations: i,
-      threshold: s
+      threshold: o
     }), h = [];
-    return await S(e, "Grouping nodes", t, (m) => {
-      h.push({ id: m, values: { group: l.communities.get(String(m)) ?? 0 } });
+    return await S(e, "Grouping nodes", t, (u) => {
+      h.push({ id: u, values: { group: d.communities.get(String(u)) ?? 0 } });
     }), {
       shape: "community",
-      fields: ee(!0),
+      fields: oe(!0),
       nodes: h,
-      graph: { modularity: l.modularity },
-      caveats: M({
+      graph: { modularity: d.modularity },
+      caveats: C({
         method: "leiden",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "strength" },
-        iterations: l.iterations,
+        iterations: d.iterations,
         notes: [`Resolution ${String(n)}.`]
       })
     };
   }
 };
-B.namespace = "graphty", B.type = "leiden", B.zodOptionsSchema = ga, B.optionsSchema = {
+Q.namespace = "graphty", Q.type = "leiden", Q.scopeInput = "subgraph", Q.zodOptionsSchema = Na, Q.optionsSchema = {
   resolution: {
     type: "number",
     default: 1,
@@ -2260,12 +2267,12 @@ B.namespace = "graphty", B.type = "leiden", B.zodOptionsSchema = ga, B.optionsSc
     advanced: !0
   }
 };
-let Ie = B;
-v.register(Ie);
-const fa = {
-  "adamic-adar": Pt,
-  "common-neighbors": Dt
-}, ya = {
+let Re = Q;
+v.register(Re);
+const ka = {
+  "adamic-adar": Wt,
+  "common-neighbors": Ht
+}, Sa = {
   method: {
     schema: c.enum(["adamic-adar", "common-neighbors"]).default("adamic-adar"),
     meta: {
@@ -2280,37 +2287,36 @@ const fa = {
       description: "How many of the best-scoring pairs to keep."
     }
   }
-}, Y = class Y extends z {
+}, A = class A extends E {
   /**
-   * Score every unconnected pair of nodes and keep the best.
+   * Score every unconnected pair of the run's nodes and keep the best. A pair is published as a
+   * row of the result and never written into the graph.
    * @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)
+    if (this.input("undirected").nodeCount === 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");
+    const i = /* @__PURE__ */ new Set(), o = ka[t](a).filter(({ source: r, target: d }) => {
+      const h = [String(r), String(d)].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({
+      graph: { pairs: o },
+      caveats: C({
         method: t,
         direction: "undirected",
         weight: null,
-        notes: [
-          "Only pairs that are not already joined, and that share at least one neighbour, are scored."
-        ]
+        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 = {
+A.namespace = "graphty", A.type = "link-prediction", A.scopeInput = "subgraph", A.zodOptionsSchema = Sa, A.optionsSchema = {
   method: {
     type: "select",
     default: "adamic-adar",
@@ -2330,9 +2336,9 @@ Y.namespace = "graphty", Y.type = "link-prediction", Y.zodOptionsSchema = ya, Y.
     max: 1e3
   }
 };
-let Me = Y;
-v.register(Me);
-const ba = {
+let $e = A;
+v.register($e);
+const Oa = {
   resolution: {
     schema: c.number().min(0.1).max(5).default(1),
     meta: {
@@ -2365,7 +2371,7 @@ const ba = {
       advanced: !0
     }
   }
-}, Z = class Z extends z {
+}, _ = class _ extends E {
   /**
    * Group the nodes into communities by optimising modularity.
    *
@@ -2376,29 +2382,29 @@ const ba = {
    * @returns The community result, or null when there are no nodes to group.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    const t = R(this.input("undirected"));
     if (t.length === 0)
       return null;
-    const { resolution: n, maxIterations: a, tolerance: i, useOptimized: s } = this.schemaOptions, r = this.algorithmGraph("undirected");
+    const { resolution: n, maxIterations: a, tolerance: i, useOptimized: o } = this.schemaOptions, r = this.algorithmGraph("undirected");
     e.report({ phase: "Optimizing modularity", total: null });
-    const l = Rt(r, {
+    const d = Kt(r, {
       resolution: n,
       maxIterations: a,
       tolerance: i,
-      useOptimized: s
+      useOptimized: o
     }), h = /* @__PURE__ */ new Map();
-    for (let d = 0; d < l.communities.length; d++)
-      for (const p of l.communities[d])
-        h.set(p, d);
-    const m = [];
-    return await S(e, "Grouping nodes", t, (d) => {
-      m.push({ id: d, values: { group: h.get(d) ?? 0 } });
+    for (let l = 0; l < d.communities.length; l++)
+      for (const p of d.communities[l])
+        h.set(p, l);
+    const u = [];
+    return await S(e, "Grouping nodes", t, (l) => {
+      u.push({ id: l, values: { group: h.get(l) ?? 0 } });
     }), {
       shape: "community",
-      fields: ee(!0),
-      nodes: m,
-      graph: { modularity: l.modularity },
-      caveats: M({
+      fields: oe(!0),
+      nodes: u,
+      graph: { modularity: d.modularity },
+      caveats: C({
         method: "louvain",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "strength" },
@@ -2407,7 +2413,7 @@ const ba = {
     };
   }
 };
-Z.namespace = "graphty", Z.type = "louvain", Z.zodOptionsSchema = ba, Z.optionsSchema = {
+_.namespace = "graphty", _.type = "louvain", _.scopeInput = "subgraph", _.zodOptionsSchema = Oa, _.optionsSchema = {
   resolution: {
     type: "number",
     default: 1,
@@ -2443,9 +2449,9 @@ Z.namespace = "graphty", Z.type = "louvain", Z.zodOptionsSchema = ba, Z.optionsS
     advanced: !0
   }
 };
-let Ce = Z;
-v.register(Ce);
-const wa = {
+let Fe = _;
+v.register(Fe);
+const xa = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -2460,7 +2466,7 @@ const wa = {
       description: "Sink node for flow network (uses last node if not set)"
     }
   }
-}, X = class X extends z {
+}, ee = class ee extends E {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -2486,60 +2492,60 @@ const wa = {
    * @returns The flow per edge, or null when there is no network to measure.
    */
   async compute(e) {
-    const t = this.graph.getDataManager(), n = Array.from(t.edges.values()), a = Array.from(t.nodes.keys());
+    const t = this.input("declared"), n = ie(t), a = R(t);
     if (n.length === 0 || a.length === 0)
       return null;
-    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 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);
+    const i = this.legacyOptions?.source ?? this._schemaOptions.source, o = this.legacyOptions?.sink ?? this._schemaOptions.sink, r = i === null ? String(a[0]) : Ye("max-flow", "source", i, a), d = o === null ? String(a[a.length - 1]) : Ye("max-flow", "sink", o, a), h = new _e({ directed: !0 });
+    for (const b of a)
+      h.addNode(String(b));
+    const u = /* @__PURE__ */ new Map();
+    for (const b of n) {
+      const w = String(b.source), O = String(b.target), I = this.edgeRecord(b.id), x = I?.capacity ?? I?.value ?? 1, T = typeof x == "number" ? x : 1, F = P(w, O), D = (u.get(F) ?? 0) + T;
+      u.set(F, D), h.removeEdge(w, O), h.addEdge(w, O, D);
     }
     e.report({ phase: "Pushing flow", total: null });
-    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 l = Lt(h, r, d), p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map();
+    for (const [b, w] of l.flowGraph)
+      for (const [O, I] of w)
+        m.set(b, (m.get(b) ?? 0) + I), p.set(O, (p.get(O) ?? 0) + I);
+    const f = [];
+    await S(e, "Measuring edges", n, (b) => {
+      const w = String(b.source), O = String(b.target), I = l.flowGraph.get(w)?.get(O) ?? 0, x = u.get(P(w, O)) ?? 1, T = x > 0 ? Math.abs(I) / x : 0;
+      f.push({ id: b.id, values: { value: I, capacity: x, utilization: T } });
     });
-    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 });
+    const M = [];
+    return await S(e, "Measuring nodes", a, (b) => {
+      const w = String(b), O = p.get(w) ?? 0, I = m.get(w) ?? 0, x = { netFlow: O - I };
+      w === r ? x.role = "source" : w === d && (x.role = "sink"), M.push({ id: b, values: x });
     }), {
       shape: "edge-metric",
       fields: [
-        ...Be("edge"),
+        ...Ae("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: x,
-      edges: g,
-      graph: { maxFlow: d.maxFlow },
-      caveats: M({
+      nodes: M,
+      edges: f,
+      graph: { maxFlow: l.maxFlow },
+      caveats: C({
         method: "ford-fulkerson",
         direction: "directed",
         weight: { attribute: "capacity", meaning: "strength" },
         notes: [
-          `Flow from ${r} to ${l}.`,
-          ...i === null || s === null ? [
+          `Flow from ${r} to ${d}.`,
+          ...i === null || o === null ? [
             "The source or sink was chosen automatically (the first and last node); set the source and sink options to measure between the nodes you mean."
           ] : [],
-          ...d.maxFlow === 0 ? [`There is no directed path from ${r} to ${l}, so no flow can run.`] : []
+          ...l.maxFlow === 0 ? [`There is no directed path from ${r} to ${d}, so no flow can run.`] : []
         ]
       })
     };
   }
 };
-X.namespace = "graphty", X.type = "max-flow", X.zodOptionsSchema = wa, X.optionsSchema = {
+ee.namespace = "graphty", ee.type = "max-flow", ee.scopeInput = "subgraph", ee.zodOptionsSchema = xa, ee.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -2555,9 +2561,9 @@ X.namespace = "graphty", X.type = "max-flow", X.zodOptionsSchema = wa, X.options
     required: !1
   }
 };
-let ze = X;
-v.register(ze);
-const va = {
+let Ge = ee;
+v.register(Ge);
+const Ia = {
   source: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -2595,7 +2601,7 @@ const va = {
       advanced: !0
     }
   }
-}, J = class J extends z {
+}, te = class te extends E {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -2627,61 +2633,61 @@ const va = {
    * @returns The edge set, or null when there is nothing to cut.
    */
   async compute(e) {
-    const t = this.graph.getDataManager(), n = Array.from(t.edges.values()), a = Array.from(t.nodes.keys());
+    const t = this.input("undirected"), n = ie(t), a = R(t);
     if (n.length === 0 || a.length === 0)
       return null;
-    const i = /* @__PURE__ */ new Map(), s = new at({ directed: !1 });
-    for (const b of a)
-      i.set(String(b), /* @__PURE__ */ new Map()), s.addNode(String(b));
-    for (const b of n) {
-      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, 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));
+    const i = t.subgraph(), { ids: o } = i, { src: r, dst: d, weights: h } = i.edgeList(), u = /* @__PURE__ */ new Map(), l = new _e({ directed: !1 });
+    for (const y of a)
+      u.set(String(y), /* @__PURE__ */ new Map()), l.addNode(String(y));
+    for (let y = 0; y < i.edgeCount; y++) {
+      const $ = String(o.idOf(r[y])), se = String(o.idOf(d[y])), Je = h === null ? 1 : h[y];
+      u.get($)?.set(se, Je), u.get(se)?.set($, Je), l.addEdge($, se, Je);
+    }
+    const p = this.legacyOptions?.useGlobalMinCut ?? this._schemaOptions.useGlobalMinCut, m = this.legacyOptions?.source ?? this._schemaOptions.source, f = this.legacyOptions?.sink ?? this._schemaOptions.sink, { useKarger: M, kargerIterations: b } = this._schemaOptions;
+    let w, O, I, x, T, F;
+    if (e.report({ phase: "Finding the cut", total: null }), p || m === null && f === null)
+      M ? (T = "karger", { partition1: w, partition2: O, cutEdges: I, cutValue: x } = Ut(u, b)) : (T = "stoer-wagner", { partition1: w, partition2: O, cutEdges: I, cutValue: x } = jt(u));
     else {
-      y = "min-st-cut";
-      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);
+      T = "min-st-cut";
+      const y = m === null ? String(a[0]) : Ye("min-cut", "source", m, a), $ = f === null ? String(a[a.length - 1]) : Ye("min-cut", "sink", f, a);
+      (m === null || f === null) && (F = `Only one end was set, so the other was chosen automatically (cut between ${y} and ${$}); set both source and sink to cut between the nodes you mean.`), { partition1: w, partition2: O, cutEdges: I, cutValue: x } = Vt(l, y, $);
     }
-    const I = /* @__PURE__ */ new Map();
-    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 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 D = /* @__PURE__ */ new Map();
+    for (const y of I)
+      D.set(P(y.from, y.to), y.weight), D.set(P(y.to, y.from), y.weight);
     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" } });
+    await S(e, "Marking the cut", n, (y) => {
+      const $ = D.get(P(y.source, y.target));
+      N.push({ id: y.id, values: { in: $ !== void 0 } });
+    });
+    const z = [];
+    return await S(e, "Marking the sides", a, (y) => {
+      const $ = w.has(String(y));
+      z.push({ id: y, values: { side: $ ? "1" : "2" } });
     }), {
       shape: "edge-set",
       fields: [
-        ...je("edge", { name: "cutValue", type: "number" }),
+        ...Ze("edge", { name: "cutValue", type: "number" }),
         { name: "side", kind: "node", type: "string" }
       ],
-      nodes: N,
-      edges: w,
+      nodes: z,
+      edges: N,
       graph: { cutValue: x },
-      caveats: M({
-        method: y,
+      caveats: C({
+        method: T,
         direction: "undirected",
         weight: { attribute: "weight", meaning: "strength" },
-        exact: y !== "karger",
-        iterations: y === "karger" ? d : void 0,
+        exact: T !== "karger",
+        iterations: T === "karger" ? b : void 0,
         notes: [
-          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]
+          T === "karger" ? "Karger's method is randomised: it finds the cheapest cut with high probability, not certainty." : `The cut separates ${String(w.size)} nodes from ${String(O.size)}.`,
+          ...F === void 0 ? [] : [F]
         ]
       })
     };
   }
 };
-J.namespace = "graphty", J.type = "min-cut", J.zodOptionsSchema = va, J.optionsSchema = {
+te.namespace = "graphty", te.type = "min-cut", te.scopeInput = "subgraph", te.zodOptionsSchema = Ia, te.optionsSchema = {
   source: {
     type: "nodeId",
     default: null,
@@ -2720,9 +2726,9 @@ J.namespace = "graphty", J.type = "min-cut", J.zodOptionsSchema = va, J.optionsS
     advanced: !0
   }
 };
-let Te = J;
-v.register(Te);
-const _e = {
+let He = te;
+v.register(He);
+const st = {
   dampingFactor: {
     schema: c.number().min(0).max(1).default(0.85),
     meta: {
@@ -2763,21 +2769,21 @@ const _e = {
       advanced: !0
     }
   }
-}, Na = $({
+}, Ca = U({
   plainName: "Influence",
   technicalName: "PageRank score"
-}), 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";
+}), Ta = 100;
+function za(s) {
+  return s.hasPersonalization ? "a personalization vector was given, and only the reference implementation takes one" : s.hasInitialRanks ? "initial ranks were given, and only the reference implementation takes them" : s.directed ? null : "the graph is undirected, and rank flows along out-edges";
 }
-const Q = class Q extends G {
+const ae = class ae extends j {
   /**
    * 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 = Xt(_e, t ?? {}), this.programmaticOptions = {
+    super(e, t), this.zodOptions = aa(st, t ?? {}), this.programmaticOptions = {
       initialRanks: t?.initialRanks ?? null,
       personalization: t?.personalization ?? null
     };
@@ -2787,7 +2793,7 @@ const Q = class Q extends G {
    * @returns The uniform node-metric fields.
    */
   resultFields() {
-    return Na;
+    return Ca;
   }
   /**
    * Rank every node by the influence flowing into it.
@@ -2796,101 +2802,101 @@ const Q = class Q extends G {
    * @returns One raw rank per node, unscaled.
    */
   async measure(e, t) {
-    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: l !== void 0,
+    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, u = za({
+      directed: this.input("declared").graph.directed,
+      hasInitialRanks: d !== void 0,
       hasPersonalization: h !== void 0
     });
-    if (m === null) {
-      const { snapshot: y, run: O } = this.accelerated("pageRank", "directed");
+    if (u === null) {
+      const { snapshot: b, run: w } = 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 O(
-        (P, H) => P.pageRank(H, {
+      const { value: O, precision: I } = await w(
+        (D, N) => D.pageRank(N, {
           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: s !== null
+          weighted: o !== null
         })
       );
       e.signal.throwIfAborted();
-      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 { ids: x } = b, T = [];
+      await W(t, e, "reading ranks", (D) => {
+        const N = x.indexOf(D), z = N === L ? void 0 : O.scores[N];
+        T.push({ id: D, values: z === void 0 ? {} : { value: z } });
       });
-      const C = [
+      const F = [
         `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 s === null && C.push("Edge weights are not read."), r && C.push(
+      return o === null && F.push("Edge weights are not read."), r && F.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,
+        nodes: T,
         normalization: "none",
         caveats: {
           exact: !0,
           direction: "directed",
-          weight: s === null ? null : { attribute: s, meaning: "strength" },
-          precision: w,
+          weight: o === null ? null : { attribute: o, meaning: "strength" },
+          precision: I,
           method: "power-iteration",
-          converged: I.converged,
-          iterations: I.iterations,
-          notes: C
+          converged: O.converged,
+          iterations: O.iterations,
+          notes: F
         }
       };
     }
-    const d = this.algorithmGraph("directed"), p = r && d.nodeCount > ka;
+    const l = this.algorithmGraph("directed"), p = r && l.nodeCount > Ta;
     e.report({
       phase: "iterating",
       completed: 0,
       total: t.length,
       message: `Power iteration, up to ${String(a)} passes.`
     });
-    const u = Wt(d, {
+    const m = qt(l, {
       dampingFactor: n,
       maxIterations: a,
       tolerance: i,
-      weight: s ?? void 0,
+      weight: o ?? void 0,
       useDelta: r,
-      initialRanks: l,
+      initialRanks: d,
       personalization: h
     });
     e.signal.throwIfAborted();
-    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 f = [];
+    await W(t, e, "reading ranks", (b) => {
+      const w = m.ranks[String(b)];
+      f.push({ id: b, values: w === void 0 ? {} : { value: w } });
     });
-    const x = [
+    const M = [
       `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}.`
+      `Computed on the CPU reference implementation: ${u}.`
     ];
-    return s === null && x.push("Edge weights are not read."), {
-      nodes: g,
+    return o === null && M.push("Edge weights are not read."), {
+      nodes: f,
       // Raw ranks, published as they were computed.
       normalization: "none",
       caveats: {
         exact: !0,
         direction: "directed",
-        weight: s === null ? null : { attribute: s, meaning: "strength" },
+        weight: o === null ? null : { attribute: o, meaning: "strength" },
         precision: "f64",
         method: p ? "delta-pagerank" : "power-iteration",
-        converged: u.converged,
-        iterations: u.iterations,
-        notes: x
+        converged: m.converged,
+        iterations: m.iterations,
+        notes: M
       }
     };
   }
 };
-Q.namespace = "graphty", Q.type = "pagerank", Q.zodOptionsSchema = _e, Q.optionsSchema = {
+ae.namespace = "graphty", ae.type = "pagerank", ae.scopeInput = "subgraph", ae.zodOptionsSchema = st, ae.optionsSchema = {
   dampingFactor: {
     type: "number",
     default: 0.85,
@@ -2934,9 +2940,9 @@ Q.namespace = "graphty", Q.type = "pagerank", Q.zodOptionsSchema = _e, Q.options
   }
   // Note: initialRanks and personalization are Map types - programmatic only, not in schema
 };
-let Ee = Q;
-v.register(Ee);
-const Oa = {
+let We = ae;
+v.register(We);
+const Ea = {
   startNode: {
     schema: c.union([c.string(), c.number()]).nullable().default(null),
     meta: {
@@ -2944,7 +2950,27 @@ const Oa = {
       description: "Starting node for MST growth (uses first node if not set)"
     }
   }
-}, _ = class _ extends z {
+};
+function Ma(s, e) {
+  if (e !== void 0 && !s.hasNode(e))
+    throw new Error(`Start node ${String(e)} not found in graph`);
+  const t = Bt(s);
+  if (t.length <= 1)
+    return tt(s, e);
+  const n = [];
+  let a = 0;
+  for (const i of t) {
+    const o = new Set(i), r = new _e({ directed: !1 });
+    for (const h of i)
+      r.addNode(h);
+    for (const h of s.edges())
+      o.has(h.source) && r.addEdge(h.source, h.target, h.weight);
+    const d = tt(r, e !== void 0 && o.has(e) ? e : void 0);
+    n.push(...d.edges), a += d.totalWeight;
+  }
+  return { edges: n, totalWeight: a };
+}
+const ne = class ne extends E {
   constructor() {
     super(...arguments), this.legacyOptions = null;
   }
@@ -2968,23 +2994,23 @@ const Oa = {
    * @returns The edge set, or null when there are no edges to choose from.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().edges.values());
+    const t = ie(this.input("undirected"));
     if (t.length === 0)
       return null;
     const n = this.legacyOptions?.startNode ?? this._schemaOptions.startNode ?? void 0, a = this.algorithmGraph("undirected");
     e.report({ phase: "Choosing edges", total: null });
-    const i = 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 i = Ma(a, n), o = /* @__PURE__ */ new Set();
+    for (const d of i.edges)
+      o.add(P(d.source, d.target)), o.add(P(d.target, d.source));
     const r = [];
-    return await S(e, "Marking the network", t, (l) => {
-      r.push({ id: l.id, values: { in: s.has(T(l.srcId, l.dstId)) } });
+    return await S(e, "Marking the network", t, (d) => {
+      r.push({ id: d.id, values: { in: o.has(P(d.source, d.target)) } });
     }), {
       shape: "edge-set",
-      fields: je("edge", { name: "totalWeight", type: "number" }),
+      fields: Ze("edge", { name: "totalWeight", type: "number" }),
       edges: r,
       graph: { totalWeight: i.totalWeight },
-      caveats: M({
+      caveats: C({
         method: "prim",
         direction: "undirected",
         weight: { attribute: "weight", meaning: "distance" },
@@ -2993,7 +3019,7 @@ const Oa = {
     };
   }
 };
-_.namespace = "graphty", _.type = "prim", _.zodOptionsSchema = Oa, _.optionsSchema = {
+ne.namespace = "graphty", ne.type = "prim", ne.scopeInput = "subgraph", ne.zodOptionsSchema = Ea, ne.optionsSchema = {
   startNode: {
     type: "nodeId",
     default: null,
@@ -3002,9 +3028,9 @@ _.namespace = "graphty", _.type = "prim", _.zodOptionsSchema = Oa, _.optionsSche
     required: !1
   }
 };
-let De = _;
-v.register(De);
-const Ue = class Ue extends z {
+let Ke = ne;
+v.register(Ke);
+const fe = class fe extends E {
   /**
    * Find the pieces of the graph that a directed path can cross both ways.
    *
@@ -3015,23 +3041,23 @@ const Ue = class Ue extends z {
    * @returns The community result, or null when there are no nodes to group.
    */
   async compute(e) {
-    const t = Array.from(this.graph.getDataManager().nodes.keys());
+    const t = R(this.input("declared"));
     if (t.length === 0)
       return null;
     const n = this.algorithmGraph("directed");
     e.report({ phase: "Finding pieces", total: null });
-    const a = Lt(n), i = /* @__PURE__ */ new Map();
+    const a = Yt(n), i = /* @__PURE__ */ new Map();
     for (let r = 0; r < a.length; r++)
-      for (const l of a[r])
-        i.set(l, r);
-    const s = [];
+      for (const d of a[r])
+        i.set(d, r);
+    const o = [];
     return await S(e, "Grouping nodes", t, (r) => {
-      s.push({ id: r, values: { group: i.get(r) ?? 0 } });
+      o.push({ id: r, values: { group: i.get(r) ?? 0 } });
     }), {
       shape: "community",
-      fields: ee(!1),
-      nodes: s,
-      caveats: M({
+      fields: oe(!1),
+      nodes: o,
+      caveats: C({
         method: "strongly-connected-components",
         direction: "directed",
         weight: null,
@@ -3040,38 +3066,38 @@ const Ue = class Ue extends z {
     };
   }
 };
-Ue.namespace = "graphty", Ue.type = "scc";
-let Pe = Ue;
-v.register(Pe);
-const xa = "results.$";
-function f(o) {
-  return { ...o, path: `${xa}.${o.name}` };
+fe.namespace = "graphty", fe.type = "scc", fe.scopeInput = "subgraph";
+let Le = fe;
+v.register(Le);
+const Da = "results.$";
+function g(s) {
+  return { ...s, path: `${Da}.${s.name}` };
 }
-function E(o, e) {
+function G(s, e) {
   return [
-    f({
+    g({
       name: "value",
       plainName: e.plainName,
       technicalName: e.technicalName,
-      kind: o,
+      kind: s,
       type: e.type ?? "number",
       ...e.unit === void 0 ? {} : { unit: e.unit }
     }),
-    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({
+    g({ name: "rank", plainName: "Rank", technicalName: "rank", kind: s, type: "integer" }),
+    g({ name: "percentile", plainName: "Percentile", technicalName: "percentile", kind: s, type: "number" }),
+    g({ name: "min", plainName: "Lowest", technicalName: "min", kind: "graph", type: "number" }),
+    g({ name: "max", plainName: "Highest", technicalName: "max", kind: "graph", type: "number" }),
+    g({ name: "median", plainName: "Middle", technicalName: "median", kind: "graph", type: "number" }),
+    g({ name: "mean", plainName: "Average", technicalName: "mean", kind: "graph", type: "number" }),
+    g({ name: "measured", plainName: "Measured", technicalName: "measured", kind: "graph", type: "integer" }),
+    g({
       name: "normalization",
       plainName: "Normalization",
       technicalName: "normalization",
       kind: "graph",
       type: "string"
     }),
-    f({
+    g({
       name: "tiedAtMin",
       plainName: "Tied at the lowest value",
       technicalName: "tiedAtMin",
@@ -3080,33 +3106,33 @@ function E(o, e) {
     })
   ];
 }
-function te(o, e) {
+function re(s, e) {
   const t = [
-    f({ name: "group", plainName: o, technicalName: "group", kind: "node", type: "integer" }),
-    f({
+    g({ name: "group", plainName: s, technicalName: "group", kind: "node", type: "integer" }),
+    g({
       name: "groupSize",
-      plainName: `${o} size`,
+      plainName: `${s} size`,
       technicalName: "groupSize",
       kind: "node",
       type: "integer"
     }),
-    f({
+    g({
       name: "groupCount",
-      plainName: `${o} count`,
+      plainName: `${s} count`,
       technicalName: "groupCount",
       kind: "graph",
       type: "integer"
     }),
-    f({
+    g({
       name: "sizes",
-      plainName: `${o} sizes`,
+      plainName: `${s} sizes`,
       technicalName: "sizes",
       kind: "graph",
       type: "table"
     })
   ];
   return e && t.push(
-    f({
+    g({
       name: "modularity",
       plainName: "Community strength",
       technicalName: "modularity",
@@ -3115,24 +3141,24 @@ function te(o, e) {
     })
   ), t;
 }
-function oe(o, e, t) {
+function qe(s, e, t) {
   return [
-    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" })
+    g({ name: "in", plainName: e, technicalName: "in", kind: s, type: "boolean" }),
+    g({ name: "count", plainName: "Count", technicalName: "count", kind: "graph", type: "integer" }),
+    g({ ...t, kind: "graph" })
   ];
 }
-function k(o) {
-  return Ae(o.getZodOptionsSchema());
+function k(s) {
+  return Qe(s.getZodOptionsSchema());
 }
-function et(...o) {
+function ot(...s) {
   const e = [], t = /* @__PURE__ */ new Set();
-  for (const n of o)
+  for (const n of s)
     for (const a of n)
       t.has(a.name) || (t.add(a.name), e.push(a));
   return e;
 }
-const Ia = {
+const Pa = {
   method: {
     schema: c.enum(["dijkstra", "bellman-ford"]).nullable().default(null),
     meta: {
@@ -3142,7 +3168,7 @@ const Ia = {
       group: "engine"
     }
   }
-}, Ma = {
+}, Ra = {
   strength: {
     schema: c.enum(["weak", "strong"]).default("weak"),
     meta: {
@@ -3150,7 +3176,7 @@ const Ia = {
       description: "Weak follows an edge in either direction. Strong needs a directed path each way, and only differs from weak on a directed graph."
     }
   }
-}, ot = [
+}, $a = [
   {
     key: "degree",
     plainName: "Connections",
@@ -3159,15 +3185,20 @@ const Ia = {
     category: "centrality",
     shape: "node-metric",
     fields: [
-      ...E("node", { plainName: "Connections", technicalName: "degree", type: "integer", unit: "links" }),
-      f({
+      ...G("node", {
+        plainName: "Connections",
+        technicalName: "degree",
+        type: "integer",
+        unit: "links"
+      }),
+      g({
         name: "inDegree",
         plainName: "Incoming connections",
         technicalName: "inDegree",
         kind: "node",
         type: "integer"
       }),
-      f({
+      g({
         name: "outDegree",
         plainName: "Outgoing connections",
         technicalName: "outDegree",
@@ -3175,7 +3206,7 @@ const Ia = {
         type: "integer"
       })
     ],
-    options: k(ge),
+    options: k(Se),
     costClass: "instant",
     complexity: "O(n + m)",
     legacyKeys: [{ key: "degree" }]
@@ -3187,8 +3218,8 @@ const Ia = {
     description: "Scores a node by how many of the shortest paths between other nodes run through it, which is what finds the bridges.",
     category: "centrality",
     shape: "node-metric",
-    fields: E("node", { plainName: "Bridging", technicalName: "betweenness" }),
-    options: k(de),
+    fields: G("node", { plainName: "Bridging", technicalName: "betweenness" }),
+    options: k(be),
     costClass: "heavy",
     complexity: "O(n * m)",
     legacyKeys: [{ key: "betweenness" }]
@@ -3200,8 +3231,8 @@ const Ia = {
     description: "Scores a node by how short its paths to the rest of the graph are, which is what finds the nodes that reach everything quickly.",
     category: "centrality",
     shape: "node-metric",
-    fields: E("node", { plainName: "Reach", technicalName: "closeness" }),
-    options: k(pe),
+    fields: G("node", { plainName: "Reach", technicalName: "closeness" }),
+    options: k(Ne),
     costClass: "heavy",
     complexity: "O(n * m)",
     legacyKeys: [{ key: "closeness" }]
@@ -3213,8 +3244,8 @@ const Ia = {
     description: "Ranks a node by the influence that flows into it from the nodes that point at it.",
     category: "centrality",
     shape: "node-metric",
-    fields: E("node", { plainName: "Influence", technicalName: "PageRank score" }),
-    options: k(Ee),
+    fields: G("node", { plainName: "Influence", technicalName: "PageRank score" }),
+    options: k(We),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "pagerank" }]
@@ -3226,8 +3257,8 @@ const Ia = {
     description: "Scores a node by how influential its neighbours are, so a few important connections count for more than many unimportant ones.",
     category: "centrality",
     shape: "node-metric",
-    fields: E("node", { plainName: "Influence by association", technicalName: "eigenvector score" }),
-    options: k(be),
+    fields: G("node", { plainName: "Influence by association", technicalName: "eigenvector score" }),
+    options: k(Ie),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "eigenvector" }]
@@ -3239,8 +3270,8 @@ const Ia = {
     description: "Scores a node by every path that reaches it, with a longer path counting for less.",
     category: "centrality",
     shape: "node-metric",
-    fields: E("node", { plainName: "Influence at a distance", technicalName: "Katz score" }),
-    options: k(ke),
+    fields: G("node", { plainName: "Influence at a distance", technicalName: "Katz score" }),
+    options: k(Ee),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "katz" }]
@@ -3253,9 +3284,9 @@ const Ia = {
     category: "centrality",
     shape: "node-metric",
     fields: [
-      ...E("node", { plainName: "Hub and authority", technicalName: "combined HITS score" }),
-      f({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
-      f({
+      ...G("node", { plainName: "Hub and authority", technicalName: "combined HITS score" }),
+      g({ name: "hub", plainName: "Hub", technicalName: "hub score", kind: "node", type: "number" }),
+      g({
         name: "authority",
         plainName: "Authority",
         technicalName: "authority score",
@@ -3263,7 +3294,7 @@ const Ia = {
         type: "number"
       })
     ],
-    options: k(Ne),
+    options: k(ze),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "hits" }]
@@ -3275,8 +3306,8 @@ const Ia = {
     description: "Groups nodes into communities by repeatedly merging the groups whose merger tightens the partition the most.",
     category: "community",
     shape: "community",
-    fields: te("Community", !0),
-    options: k(Ce),
+    fields: re("Community", !0),
+    options: k(Fe),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "louvain" }]
@@ -3288,8 +3319,8 @@ const Ia = {
     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: te("Community", !0),
-    options: k(Ie),
+    fields: re("Community", !0),
+    options: k(Re),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "leiden" }]
@@ -3301,8 +3332,8 @@ const Ia = {
     description: "Groups nodes into communities by letting every node repeatedly take whichever label most of its neighbours carry.",
     category: "community",
     shape: "community",
-    fields: te("Community", !1),
-    options: k(xe),
+    fields: re("Community", !1),
+    options: k(Pe),
     costClass: "iterative",
     complexity: "O(k(n + m))",
     legacyKeys: [{ key: "label-propagation" }]
@@ -3314,8 +3345,8 @@ const Ia = {
     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: te("Community", !0),
-    options: k(ve),
+    fields: re("Community", !0),
+    options: k(Te),
     costClass: "heavy",
     complexity: "O(n * m^2)",
     legacyKeys: [{ key: "girvan-newman" }]
@@ -3327,11 +3358,11 @@ const Ia = {
     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: te("Piece", !1),
-    options: et(
-      k(me),
-      k(Pe),
-      Ae(Ma)
+    fields: re("Piece", !1),
+    options: ot(
+      k(ke),
+      k(Le),
+      Qe(Ra)
     ),
     costClass: "instant",
     complexity: "O(n + m)",
@@ -3345,14 +3376,50 @@ const Ia = {
     category: "path",
     shape: "path",
     fields: [
-      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({
+      g({
+        name: "onPath",
+        plainName: "On the route",
+        technicalName: "onPath",
+        kind: "node",
+        type: "boolean"
+      }),
+      g({
+        name: "order",
+        plainName: "Position on the route",
+        technicalName: "order",
+        kind: "node",
+        type: "integer"
+      }),
+      g({
+        name: "distance",
+        plainName: "Distance from the source",
+        technicalName: "distance",
+        kind: "node",
+        type: "number"
+      }),
+      g({
+        name: "onPath",
+        plainName: "On the route",
+        technicalName: "onPath",
+        kind: "edge",
+        type: "boolean"
+      }),
+      g({
+        name: "length",
+        plainName: "Nodes on the route",
+        technicalName: "length",
+        kind: "graph",
+        type: "integer"
+      }),
+      g({ name: "cost", plainName: "Total cost", technicalName: "cost", kind: "graph", type: "number" }),
+      g({
+        name: "hops",
+        plainName: "Edges on the route",
+        technicalName: "hops",
+        kind: "graph",
+        type: "integer"
+      }),
+      g({
         name: "hasNegativeCycle",
         plainName: "Has a loop that costs less every time round",
         technicalName: "hasNegativeCycle",
@@ -3360,10 +3427,10 @@ const Ia = {
         type: "boolean"
       })
     ],
-    options: et(
+    options: ot(
+      k(xe),
       k(ye),
-      k(le),
-      Ae(Ia)
+      Qe(Pa)
     ),
     costClass: "instant",
     complexity: "O((n + m) log n) with dijkstra, O(n * m) with bellman-ford",
@@ -3388,10 +3455,22 @@ const Ia = {
     category: "path",
     shape: "node-metric",
     fields: [
-      ...E("node", { plainName: "Distance to the furthest node", technicalName: "eccentricity" }),
-      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({
+      ...G("node", { plainName: "Distance to the furthest node", technicalName: "eccentricity" }),
+      g({
+        name: "diameter",
+        plainName: "Widest distance",
+        technicalName: "diameter",
+        kind: "graph",
+        type: "number"
+      }),
+      g({
+        name: "radius",
+        plainName: "Narrowest distance",
+        technicalName: "radius",
+        kind: "graph",
+        type: "number"
+      }),
+      g({
         name: "hasNegativeCycle",
         plainName: "Has a loop that costs less every time round",
         technicalName: "hasNegativeCycle",
@@ -3399,7 +3478,7 @@ const Ia = {
         type: "boolean"
       })
     ],
-    options: k(we),
+    options: k(Ce),
     costClass: "cubic",
     complexity: "O(n^3)",
     legacyKeys: [{ key: "floyd-warshall" }]
@@ -3412,14 +3491,32 @@ const Ia = {
     category: "path",
     shape: "layered-grouping",
     fields: [
-      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" })
+      g({ name: "level", plainName: "Steps away", technicalName: "level", kind: "node", type: "integer" }),
+      g({
+        name: "levelSize",
+        plainName: "Nodes this many steps away",
+        technicalName: "levelSize",
+        kind: "node",
+        type: "integer"
+      }),
+      g({ name: "order", plainName: "Visit order", technicalName: "order", kind: "node", type: "integer" }),
+      g({
+        name: "levelCount",
+        plainName: "Levels",
+        technicalName: "levelCount",
+        kind: "graph",
+        type: "integer"
+      }),
+      g({ name: "sizes", plainName: "Level sizes", technicalName: "sizes", kind: "graph", type: "table" }),
+      g({
+        name: "targetFound",
+        plainName: "Target reached",
+        technicalName: "targetFound",
+        kind: "graph",
+        type: "boolean"
+      })
     ],
-    options: k(he),
+    options: k(we),
     costClass: "instant",
     complexity: "O(n + m)",
     legacyKeys: [{ key: "bfs" }]
@@ -3432,10 +3529,14 @@ const Ia = {
     category: "path",
     shape: "node-metric",
     fields: [
-      ...E("node", { plainName: "Exploration order", technicalName: "discovery time", type: "integer" }),
-      f({ name: "visited", plainName: "Reached", technicalName: "visited", kind: "node", type: "boolean" })
+      ...G("node", {
+        plainName: "Exploration order",
+        technicalName: "discovery time",
+        type: "integer"
+      }),
+      g({ name: "visited", plainName: "Reached", technicalName: "visited", kind: "node", type: "boolean" })
     ],
-    options: k(fe),
+    options: k(Oe),
     costClass: "instant",
     complexity: "O(n + m)",
     legacyKeys: [{ key: "dfs" }]
@@ -3447,13 +3548,13 @@ const Ia = {
     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: oe("edge", "In the network", {
+    fields: qe("edge", "In the network", {
       name: "totalWeight",
       plainName: "Total cost",
       technicalName: "totalWeight",
       type: "number"
     }),
-    options: k(Oe),
+    options: k(De),
     costClass: "instant",
     complexity: "O(m log m)",
     requires: { directed: !1 },
@@ -3466,13 +3567,13 @@ const Ia = {
     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: oe("edge", "In the network", {
+    fields: qe("edge", "In the network", {
       name: "totalWeight",
       plainName: "Total cost",
       technicalName: "totalWeight",
       type: "number"
     }),
-    options: k(De),
+    options: k(Ke),
     costClass: "instant",
     complexity: "O(m log n)",
     requires: { directed: !1 },
@@ -3486,16 +3587,16 @@ const Ia = {
     category: "structure",
     shape: "edge-set",
     fields: [
-      ...oe("edge", "In the pairing", {
+      ...qe("edge", "In the pairing", {
         name: "bipartite",
         plainName: "Has two sides",
         technicalName: "bipartite",
         type: "boolean"
       }),
-      f({ name: "side", plainName: "Side", technicalName: "side", kind: "node", type: "string" }),
-      f({ name: "matched", plainName: "Paired", technicalName: "matched", kind: "node", type: "boolean" })
+      g({ name: "side", plainName: "Side", technicalName: "side", kind: "node", type: "string" }),
+      g({ name: "matched", plainName: "Paired", technicalName: "matched", kind: "node", type: "boolean" })
     ],
-    options: k(ue),
+    options: k(ve),
     costClass: "heavy",
     complexity: "O(n * m)",
     requires: { directed: !1 },
@@ -3509,14 +3610,26 @@ const Ia = {
     category: "flow",
     shape: "edge-metric",
     fields: [
-      ...E("edge", { plainName: "Flow", technicalName: "flow" }),
-      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" })
+      ...G("edge", { plainName: "Flow", technicalName: "flow" }),
+      g({ name: "capacity", plainName: "Capacity", technicalName: "capacity", kind: "edge", type: "number" }),
+      g({
+        name: "utilization",
+        plainName: "Share of capacity used",
+        technicalName: "utilization",
+        kind: "edge",
+        type: "number"
+      }),
+      g({ name: "netFlow", plainName: "Net flow", technicalName: "netFlow", kind: "node", type: "number" }),
+      g({ name: "role", plainName: "Source or sink", technicalName: "role", kind: "node", type: "string" }),
+      g({
+        name: "maxFlow",
+        plainName: "Most that can flow",
+        technicalName: "maxFlow",
+        kind: "graph",
+        type: "number"
+      })
     ],
-    options: k(ze),
+    options: k(Ge),
     costClass: "heavy",
     complexity: "O(n * m^2)",
     legacyKeys: [{ key: "max-flow" }]
@@ -3529,15 +3642,15 @@ const Ia = {
     category: "flow",
     shape: "edge-set",
     fields: [
-      ...oe("edge", "In the cut", {
+      ...qe("edge", "In the cut", {
         name: "cutValue",
         plainName: "Cost of the cut",
         technicalName: "cutValue",
         type: "number"
       }),
-      f({ name: "side", plainName: "Side", technicalName: "side", kind: "node", type: "string" })
+      g({ name: "side", plainName: "Side", technicalName: "side", kind: "node", type: "string" })
     ],
-    options: k(Te),
+    options: k(He),
     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" }]
@@ -3549,8 +3662,8 @@ const Ia = {
     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),
+    fields: G("node", { plainName: "Core depth", technicalName: "core number", type: "integer" }),
+    options: k(Me),
     costClass: "instant",
     complexity: "O(n + m)",
     legacyKeys: [{ key: "k-core" }]
@@ -3563,65 +3676,102 @@ const Ia = {
     category: "prediction",
     shape: "pair-list",
     fields: [
-      f({ name: "pairs", plainName: "Likely new links", technicalName: "pairs", kind: "graph", type: "table" })
+      g({
+        name: "pairs",
+        plainName: "Likely new links",
+        technicalName: "pairs",
+        kind: "graph",
+        type: "table"
+      })
     ],
-    options: k(Me),
+    options: k($e),
     costClass: "heavy",
     complexity: "O(n^2 * d)",
     legacyKeys: [{ key: "link-prediction" }]
   }
-];
-function ja(o) {
-  return ot.find((e) => e.key === o);
+], Fa = new Map(
+  [
+    ye,
+    be,
+    we,
+    ve,
+    Ne,
+    ke,
+    Se,
+    Oe,
+    xe,
+    Ie,
+    Ce,
+    Te,
+    ze,
+    Ee,
+    Me,
+    De,
+    Pe,
+    Re,
+    $e,
+    Fe,
+    Ge,
+    He,
+    We,
+    Ke,
+    Le
+  ].map((s) => [s.type, s])
+), ht = $a.map((s) => ({
+  ...s,
+  scopeInput: s.legacyKeys.every((e) => Fa.get(e.key)?.scopeInput === "subgraph") ? "subgraph" : "none"
+}));
+function Aa(s) {
+  return ht.find((e) => e.key === s);
 }
-function Va(o) {
-  for (const e of ot)
+function _a(s) {
+  for (const e of ht)
     for (const t of e.legacyKeys)
-      if (t.key === o)
+      if (t.key === s)
         return { descriptor: e, params: t.params ?? {} };
 }
 export {
-  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
+  He as A,
+  ht as B,
+  lt as C,
+  Se as D,
+  Ie as E,
+  Ce as F,
+  Te as G,
+  ze as H,
+  Me as I,
+  $e as J,
+  Ee as K,
+  Fe as L,
+  Ge as M,
+  _t as N,
+  ta as O,
+  We as P,
+  Le as S,
+  dt as a,
+  Ue as b,
+  Aa as c,
+  _a as d,
+  Ja as e,
+  Xa as f,
+  Ya as g,
+  Za as h,
+  Va as i,
+  qa as j,
+  Qa as k,
+  ea as l,
+  Ba as m,
+  xe as n,
+  be as o,
+  Ne as p,
+  Re as q,
+  Pe as r,
+  ye as s,
+  Xt as t,
+  we as u,
+  Oe as v,
+  ke as w,
+  De as x,
+  Ke as y,
+  ve as z
 };