@graphty/cytoscape-extensions 0.0.28 → 0.0.30

package/dist/algorithms.js

@@ -0,0 +1,1184 @@
+/**
+ * Every @graphty/algorithms algorithm as a Cytoscape.js 3.x collection and core method, named "graphty<Name>".
+ *
+ * The conventions, which follow Cytoscape's built-in algorithms:
+ * - scope is the calling collection (its nodes, and its edges whose two ends are in it); `cy.graphtyX(o)` is
+ *   `cy.elements().graphtyX(o)`;
+ * - synchronous, one options object;
+ * - `directed` (default false) and `weight` (an edge data field, or a function of the edge) describe the graph;
+ * - nodes are named by a selector or a collection (`root`, `goal`, `source`, `sink`, ...);
+ * - results are keyed by element: accessor functions (`score(node)`, `distanceTo(node)`), collections, and arrays
+ *   of collections, never index arrays;
+ * - `field` writes the per-element value (what `score` or `cluster` returns) into `data(field)`, so a stylesheet
+ *   can map it;
+ * - every other option the method's type lists goes to the @graphty/algorithms function unchanged, and an option it
+ *   does not list throws (src/algorithm-options.ts, generated from those types);
+ * - errors throw, from the adapter (a selection that matches nothing, a weight given to an algorithm that ignores
+ *   weights, an unknown option) and from the algorithm (an undirected graph given to one that needs a directed one),
+ *   each message starting with the method name.
+ */
+import { accelerated, adamicAdarForPairs, adamicAdarPrediction, adamicAdarScore, allPairsShortestPath, astar, bellmanFord, betweennessCentrality, bidirectionalDijkstra, breadthFirstSearch, closenessCentrality, commonNeighborsForPairs, commonNeighborsPrediction, commonNeighborsScore, condensation, connectedComponents, degreeCentrality, degrees, DeltaPageRank, depthFirstSearch, dijkstra, directionOptimizedBfs, edgeBetweennessCentrality, eigenvectorCentrality, evaluateAdamicAdar, evaluateCommonNeighbors, findAllIsomorphisms, getTopAdamicAdarCandidatesForNode, getTopCandidatesForNode, girvanNewman, greedyBipartiteMatching, grsbm, hasCycle, hierarchicalClustering, hits, isBipartite, isGraphIsomorphic, kargerMinCut, katzCentrality, kCoreDecomposition, kruskalMST, labelPropagation, labelPropagationSemiSupervised, labelPropagationSynchronous, leiden, louvain, markovClustering, maxFlow, maximumBipartiteMatching, minSTCut, modularity, nodeClosenessCentrality, pageRank, personalizedPageRank, primMST, PriorityDeltaPageRank, spectralClustering, stoerWagner, stronglyConnectedComponents, syncClustering, teraHAC, topologicalSort, triangleCount, weaklyConnectedComponents, } from "@graphty/algorithms";
+import { INVALID_INDEX, makeMask, maskSet, maskTest, } from "@graphty/graph-format";
+import { OPTION_NAMES } from "./algorithm-options.js";
+import { backendOf, checkGpuMode, coreDestroyedError, gpuFor, recording, warnIfFixable, } from "./gpu.js";
+import { coreOf, hold, indexOf, indicesOf, toSnapshot, writeData, } from "./snapshot.js";
+/**
+ * The CPU functions behind the dispatcher methods the WebGPU accelerator implements (its `createAccelerator`
+ * list), under the dispatcher's names. The plain methods call these directly, so they stay synchronous.
+ */
+const CPU = {
+    breadthFirstSearch,
+    sssp: dijkstra,
+    bellmanFord,
+    allPairsShortestPath,
+    pageRank,
+    personalizedPageRank,
+    eigenvectorCentrality,
+    katzCentrality,
+    hits,
+    closenessCentrality,
+    betweennessCentrality,
+    edgeBetweennessCentrality,
+    connectedComponents,
+    weaklyConnectedComponents,
+    triangleCount,
+    labelPropagation,
+    labelPropagationSynchronous,
+};
+/**
+ * Applies a function to a value that is either plain (a CPU run) or a promise (a dispatcher run).
+ * @param x - the value or its promise
+ * @param f - the function
+ * @returns f(x), or its promise
+ */
+function then(x, f) {
+    return x instanceof Promise ? x.then(f) : f(x);
+}
+// Options the adapter consumes and converts; everything else passes through to the algorithm.
+const ADAPTER_KEYS = new Set([
+    "gpu",
+    "directed",
+    "weight",
+    "field",
+    "root",
+    "goal",
+    "target",
+    "source",
+    "sink",
+    "heuristic",
+    "personalization",
+    "seeds",
+    "left",
+    "right",
+    "clusters",
+    "pairs",
+    "edges",
+    "nonEdges",
+    "nodeMatch",
+    "edgeMatch",
+    "priority",
+    "candidates",
+    "sources",
+    "alive",
+    "startVector",
+    "initialRanks",
+]);
+// Algorithms that read no weights: a `weight` option would be silently ignored, so it throws.
+export const UNWEIGHTED = new Set([
+    "breadthFirstSearch",
+    "directionOptimizedBfs",
+    "depthFirstSearch",
+    "hasCycle",
+    "topologicalSort",
+    "degreeCentrality",
+    "degrees",
+    "eigenvectorCentrality",
+    "betweennessCentrality",
+    "edgeBetweennessCentrality",
+    "connectedComponents",
+    "weaklyConnectedComponents",
+    "stronglyConnectedComponents",
+    "condensation",
+    "kCoreDecomposition",
+    "triangleCount",
+    "isBipartite",
+    "isGraphIsomorphic",
+    "findAllIsomorphisms",
+    "hierarchicalClustering",
+    "teraHAC",
+    "syncClustering",
+    "maximumBipartiteMatching",
+    "greedyBipartiteMatching",
+    "commonNeighborsScore",
+    "adamicAdarScore",
+    "commonNeighborsPrediction",
+    "adamicAdarPrediction",
+    "commonNeighborsForPairs",
+    "adamicAdarForPairs",
+    "topCandidatesForNode",
+    "topAdamicAdarCandidatesForNode",
+    "evaluateCommonNeighbors",
+    "evaluateAdamicAdar",
+    "compareAdamicAdarWithCommonNeighbors",
+]);
+// Algorithms whose result has no per-element value to write: a `field` option would be silently ignored, so it throws.
+export const NO_FIELD = new Set([
+    "hasCycle",
+    "topologicalSort",
+    "bidirectionalDijkstra",
+    "aStar",
+    "allPairsShortestPath",
+    "degrees",
+    "nodeClosenessCentrality",
+    "isGraphIsomorphic",
+    "findAllIsomorphisms",
+    "modularity",
+    "hierarchicalClustering",
+    "kruskalMST",
+    "primMST",
+    "maximumBipartiteMatching",
+    "greedyBipartiteMatching",
+    "commonNeighborsScore",
+    "adamicAdarScore",
+    "commonNeighborsPrediction",
+    "adamicAdarPrediction",
+    "commonNeighborsForPairs",
+    "adamicAdarForPairs",
+    "topCandidatesForNode",
+    "topAdamicAdarCandidatesForNode",
+    "evaluateCommonNeighbors",
+    "evaluateAdamicAdar",
+    "compareAdamicAdarWithCommonNeighbors",
+]);
+// This package's own defaults, passed explicitly to @graphty/algorithms (and through it to the GPU), so a change of
+// a library default does not change what a Cytoscape user gets. docs/reference/algorithms.md shows them; a caller's
+// option overrides them. `weighted` is pinned separately: it is true exactly when the caller passed `weight`.
+const POWER = { maxIterations: 100, tolerance: 1e-6 };
+const PAGERANK = { ...POWER, dampingFactor: 0.85 };
+export const DEFAULTS = {
+    pageRank: PAGERANK,
+    personalizedPageRank: PAGERANK,
+    deltaPageRank: PAGERANK,
+    eigenvectorCentrality: POWER,
+    hits: POWER,
+    katzCentrality: { ...POWER, alpha: 0.1, beta: 1 },
+    labelPropagation: { maxIterations: 100 },
+    labelPropagationSynchronous: { maxIterations: 100 },
+    labelPropagationSemiSupervised: { maxIterations: 100 },
+    allPairsShortestPath: { paths: true },
+    maxFlow: { algorithm: "edmonds-karp" },
+    minSTCut: { algorithm: "ford-fulkerson" },
+};
+// Algorithms defined only for directed graphs: `directed` defaults to true.
+export const DIRECTED = new Set([
+    "topologicalSort",
+    "stronglyConnectedComponents",
+    "condensation",
+    "deltaPageRank",
+]);
+// ---------------------------------------------------------------------------------------------------------------
+// Conversions between elements and indices
+/**
+ * A collection of elements, in the given order. Cytoscape accepts an element array at run time; its typings declare
+ * only element definitions, hence the cast.
+ * @param c - the context
+ * @param eles - the elements
+ * @returns the collection
+ */
+function collect(c, eles) {
+    return c.cy.collection(eles);
+}
+/**
+ * Throws on a negative edge weight, which Dijkstra and A* cannot take (on an undirected graph Dijkstra would never
+ * return). The code matches graphtyBidirectionalDijkstra's error.
+ * @param c - the context
+ */
+function nonNegative(c) {
+    if (c.s.weights?.some((w) => w < 0) === true) {
+        throw Object.assign(new Error(`${c.name}: a weight is negative; use graphtyBellmanFord`), {
+            code: "E_BAD_WEIGHT",
+        });
+    }
+}
+/**
+ * The index of a required node option.
+ * @param c - the context
+ * @param sel - the option value
+ * @param what - the option name
+ * @returns the node index
+ */
+function req(c, sel, what) {
+    const i = indexOf(c.cs, sel, `${c.name}: ${what}`);
+    if (i === undefined) {
+        throw new Error(`${c.name}: the ${what} option is required`);
+    }
+    return i;
+}
+/**
+ * The index of a node or edge reference, or undefined when it is not in the snapshot.
+ * @param c - the context
+ * @param ref - an element or a selector
+ * @param edges - look among the edges instead of the nodes
+ * @returns the index
+ */
+function lookup(c, ref, edges = false) {
+    const list = (edges ? c.cs.edges : c.cs.nodes);
+    // a selector goes through Cytoscape's own matching (a collection has no find() that takes one)
+    const matches = typeof ref === "string" ? list.filter(ref) : ref;
+    const ele = matches[0];
+    if (ele === undefined) {
+        return undefined;
+    }
+    if (!edges) {
+        const i = c.s.ids.indexOf(ele.id());
+        return i === INVALID_INDEX ? undefined : i;
+    }
+    // ponytail: linear scan per edge lookup; an id -> index map if edge accessors show up in a profile.
+    const i = c.cs.edges.toArray().indexOf(ele);
+    return i < 0 ? undefined : i;
+}
+/**
+ * An accessor from element to value.
+ * @param c - the context
+ * @param values - one value per node (or edge) index
+ * @param edges - the values are per edge
+ * @returns the accessor
+ */
+function accessor(c, values, edges = false) {
+    return (ref) => {
+        const i = lookup(c, ref, edges);
+        return i === undefined ? undefined : values[i];
+    };
+}
+/**
+ * The nodes at some indices, as a collection in that order.
+ * @param c - the context
+ * @param idx - node indices
+ * @returns the collection
+ */
+function nodesAt(c, idx) {
+    return collect(c, Array.from(idx, (i) => c.cs.nodes[i]));
+}
+/**
+ * The edges at some indices, as a collection in that order.
+ * @param c - the context
+ * @param idx - edge indices
+ * @returns the collection
+ */
+function edgesAt(c, idx) {
+    return collect(c, Array.from(idx, (i) => c.cs.edges[i]));
+}
+/**
+ * A path as Cytoscape's path algorithms return it: node, edge, node, ...
+ * @param c - the context
+ * @param nodes - node indices along the path
+ * @param edges - edge indices along the path, one fewer
+ * @returns the collection
+ */
+function pathOf(c, nodes, edges) {
+    const out = [];
+    for (let k = 0; k < nodes.length; k++) {
+        if (k > 0) {
+            out.push(c.cs.edges[edges[k - 1]]);
+        }
+        out.push(c.cs.nodes[nodes[k]]);
+    }
+    return collect(c, out);
+}
+/**
+ * The node indices of each selection in a list.
+ * @param c - the context
+ * @param pairs - node pairs
+ * @param what - the option name
+ * @returns the sources and targets
+ */
+function pairsOf(c, pairs, what) {
+    if (pairs === undefined) {
+        throw new Error(`${c.name}: the ${what} option is required`);
+    }
+    return { sources: pairs.map((p) => req(c, p[0], what)), targets: pairs.map((p) => req(c, p[1], what)) };
+}
+/**
+ * A node mask of a selection.
+ * @param c - the context
+ * @param sel - a selection, or undefined
+ * @returns the mask, or undefined
+ */
+function maskOf(c, sel) {
+    if (sel === undefined) {
+        return undefined;
+    }
+    const m = makeMask(c.s.nodeCount);
+    for (const i of indicesOf(c.cs, sel)) {
+        maskSet(m, i, true);
+    }
+    return m;
+}
+// ---------------------------------------------------------------------------------------------------------------
+// Result builders
+/**
+ * A score result: `score(ele)` plus extras; writes `field`.
+ * @param c - the context
+ * @param values - one value per node (or edge) index
+ * @param extra - other fields of the result
+ * @param edges - the values are per edge
+ * @returns the result
+ */
+function scored(c, values, extra, edges = false) {
+    if (c.field !== undefined) {
+        writeData(edges ? c.cs.edges : c.cs.nodes, values, c.field);
+    }
+    return { score: accessor(c, values, edges), ...extra };
+}
+/**
+ * A partition: one node collection per label, with `cluster(node)` and extras; writes `field`.
+ * @param c - the context
+ * @param labels - the label of every node index, 0..count-1 (INVALID_INDEX: in no cluster)
+ * @param extra - other fields of the result
+ * @returns the partition
+ */
+function partition(c, labels, extra) {
+    const groups = [];
+    for (let i = 0; i < labels.length; i++) {
+        const l = labels[i];
+        if (l !== INVALID_INDEX) {
+            const group = groups[l] ?? [];
+            group.push(i);
+            groups[l] = group;
+        }
+    }
+    if (c.field !== undefined) {
+        writeData(c.cs.nodes, labels, c.field);
+    }
+    const out = Array.from(groups, (g) => nodesAt(c, g ?? []));
+    return Object.assign(out, extra, {
+        cluster: (ref) => {
+            const i = lookup(c, ref);
+            return i === undefined || labels[i] === INVALID_INDEX ? undefined : labels[i];
+        },
+    });
+}
+/**
+ * A walk result (BFS, DFS).
+ * @param c - the context
+ * @param r - the walk
+ * @param r.order - visited node indices in visit order
+ * @param r.parent - parent node index per node
+ * @param r.depth - depth per node
+ * @param r.visitedCount - number of visited nodes
+ * @param target - the target index, if any
+ * @returns the search result
+ */
+function search(c, r, target) {
+    const out = [];
+    for (let k = 0; k < r.visitedCount; k++) {
+        const v = r.order[k];
+        const p = r.parent[v];
+        if (p !== INVALID_INDEX) {
+            // The walk records the parent node, not the arc, so the tree edge is looked up: the first edge of the
+            // collection joining the two (CPU BFS/DFS results have no `predArc`, unlike Dijkstra's).
+            const from = c.cs.nodes[p];
+            const to = c.cs.nodes[v];
+            const joining = c.s.directed ? from.edgesTo(to) : from.edgesWith(to);
+            const e = joining.intersection(c.cs.edges)[0];
+            if (e !== undefined) {
+                out.push(e);
+            }
+        }
+        out.push(c.cs.nodes[v]);
+    }
+    const reached = target !== undefined && r.depth[target] !== INVALID_INDEX;
+    if (c.field !== undefined) {
+        writeData(c.cs.nodes, Array.from(r.depth, (d) => (d === INVALID_INDEX ? Number.NaN : d)), c.field);
+    }
+    return {
+        path: collect(c, out),
+        found: collect(c, reached ? [c.cs.nodes[target]] : []),
+        depth: (ref) => {
+            const i = lookup(c, ref);
+            return i === undefined || r.depth[i] === INVALID_INDEX ? undefined : r.depth[i];
+        },
+        parent: (ref) => {
+            const i = lookup(c, ref);
+            return i === undefined || r.parent[i] === INVALID_INDEX ? undefined : c.cs.nodes[r.parent[i]];
+        },
+    };
+}
+/**
+ * A single-source shortest-path result.
+ * @param c - the context
+ * @param r - the result
+ * @param r.dist - distance per node
+ * @param r.pathTo - node path to a target
+ * @param r.pathEdges - edge path to a target
+ * @returns the accessors
+ */
+function paths(c, r) {
+    if (c.field !== undefined) {
+        writeData(c.cs.nodes, r.dist, c.field);
+    }
+    return {
+        distanceTo: (ref) => {
+            const i = lookup(c, ref);
+            return i === undefined ? Infinity : r.dist[i];
+        },
+        pathTo: (ref) => {
+            const i = lookup(c, ref);
+            return i === undefined ? c.cy.collection() : pathOf(c, r.pathTo(i), r.pathEdges(i));
+        },
+    };
+}
+/**
+ * A cut result.
+ * @param c - the context
+ * @param side - the first side as a node mask
+ * @param cutEdges - the cut edge indices
+ * @param value - the cut's weight
+ * @returns the cut
+ */
+function cutOf(c, side, cutEdges, value) {
+    const first = [];
+    const second = [];
+    for (let i = 0; i < c.s.nodeCount; i++) {
+        (maskTest(side, i) ? first : second).push(i);
+    }
+    if (c.field !== undefined) {
+        writeData(c.cs.nodes, Array.from({ length: c.s.nodeCount }, (_, i) => (maskTest(side, i) ? 0 : 1)), c.field);
+    }
+    return { value, cut: edgesAt(c, cutEdges), partitionFirst: nodesAt(c, first), partitionSecond: nodesAt(c, second) };
+}
+/**
+ * A minimum cut result.
+ * @param c - the context
+ * @param r - the cut
+ * @returns the cut
+ */
+function minCut(c, r) {
+    return cutOf(c, r.side, r.cutEdges, r.cutValue);
+}
+/**
+ * Predicted links with their nodes.
+ * @param c - the context
+ * @param r - the prediction
+ * @returns one entry per predicted pair, best first
+ */
+function links(c, r) {
+    return Array.from(r.scores, (score, k) => ({
+        source: c.cs.nodes[r.sources[k]],
+        target: c.cs.nodes[r.targets[k]],
+        score,
+    }));
+}
+/**
+ * A node-to-node mapping accessor.
+ * @param c - the context
+ * @param other - the image collection's snapshot
+ * @param mapping - image index per node index
+ * @returns the accessor
+ */
+function mapper(c, other, mapping) {
+    return (ref) => {
+        const i = lookup(c, ref);
+        return i === undefined ? undefined : other.nodes[mapping[i]];
+    };
+}
+/**
+ * The two-snapshot isomorphism options, with element callbacks turned into index callbacks.
+ * @param c - the context
+ * @param other - the second graph
+ * @param o - the options
+ * @returns the options for @graphty/algorithms
+ */
+function isoOptions(c, other, o) {
+    const { nodeMatch, edgeMatch } = o;
+    return {
+        ...c.rest,
+        nodeMatch: nodeMatch && ((a, b) => nodeMatch(c.cs.nodes[a], other.nodes[b])),
+        edgeMatch: edgeMatch && ((a, b) => edgeMatch(c.cs.edges[a], other.edges[b])),
+    };
+}
+/**
+ * The snapshot of the second graph of an isomorphism test, read like the first.
+ * @param c - the context
+ * @param o - the options naming it
+ * @returns its snapshot
+ */
+function otherOf(c, o) {
+    const other = o.other;
+    // required by the type, checked for callers without types
+    if (other === undefined) {
+        throw new Error(`${c.name}: the other option (the collection to compare with) is required`);
+    }
+    // a selector (over the whole core) or an array of elements names the other graph too
+    let eles = other;
+    if (typeof other === "string") {
+        eles = c.cy.$(other);
+    }
+    else if (Array.isArray(other)) {
+        // Cytoscape takes an array of elements here; its typings list only definitions
+        eles = c.cy.collection(other);
+    }
+    if (typeof eles?.nodes !== "function") {
+        throw new TypeError(`${c.name}: the other option must be a Cytoscape collection, a selector or an array of elements`);
+    }
+    return toSnapshot(eles, { directed: c.s.directed });
+}
+/**
+ * A per-node vector from a function of the node or a selection (1 for selected nodes, 0 for the rest).
+ * @param c - the context
+ * @param v - the function or selection
+ * @param what - the option name
+ * @returns the vector
+ */
+function vectorOf(c, v, what) {
+    if (v === undefined) {
+        throw new Error(`${c.name}: the ${what} option is required`);
+    }
+    if (typeof v === "function") {
+        return Float64Array.from(c.cs.nodes.toArray(), (n) => v(n));
+    }
+    const out = new Float64Array(c.s.nodeCount);
+    for (const i of indicesOf(c.cs, v)) {
+        out[i] = 1;
+    }
+    return out;
+}
+/**
+ * The teleport vector of a personalized PageRank. One that selects no node would run plain PageRank without a word,
+ * so it throws, as a required node option that matches nothing does.
+ * @param c - the context
+ * @param v - the selection or the weight function
+ * @returns the vector
+ */
+function teleportOf(c, v) {
+    const p = vectorOf(c, v, "personalization");
+    if (!p.some((x) => x > 0)) {
+        throw new Error(`${c.name}: personalization ${typeof v === "function" ? "gives no node a positive weight" : "matches no node"}`);
+    }
+    return p;
+}
+/**
+ * Labels per node from a list of clusters or a node data field.
+ * @param c - the context
+ * @param clusters - the clusters, or the data field holding each node's cluster
+ * @param what - the option name, for the error
+ * @returns label per node index (INVALID_INDEX: none)
+ */
+function labelsOf(c, clusters, what) {
+    if (clusters === undefined) {
+        throw new Error(`${c.name}: the ${what} option is required`);
+    }
+    const labels = new Uint32Array(c.s.nodeCount).fill(INVALID_INDEX);
+    if (typeof clusters === "string") {
+        const ids = new Map();
+        c.cs.nodes.forEach((n, i) => {
+            const v = n.data(clusters);
+            if (v !== undefined) {
+                labels[i] = ids.get(v) ?? ids.set(v, ids.size).size - 1;
+            }
+        });
+    }
+    else {
+        clusters.forEach((sel, k) => {
+            for (const i of indicesOf(c.cs, sel)) {
+                labels[i] = k;
+            }
+        });
+    }
+    // a misspelled field or selector would otherwise give a plausible result (modularity 0, an unseeded partition)
+    if (labels.every((l) => l === INVALID_INDEX)) {
+        throw new Error(typeof clusters === "string"
+            ? `${c.name}: ${what} names the data field "${clusters}", which no node has`
+            : `${c.name}: ${what} matches no node`);
+    }
+    return labels;
+}
+/**
+ * The all-pairs accessors.
+ * @param c - the context
+ * @param r - the distance matrix, with the path walkers when it was run with `paths: true`
+ * @returns the accessors
+ */
+function apsp(c, r) {
+    const pair = (a, b) => {
+        const i = lookup(c, a);
+        const j = lookup(c, b);
+        return i === undefined || j === undefined ? undefined : [i, j];
+    };
+    return {
+        hasNegativeWeightCycle: r.hasNegativeCycle,
+        distance: (a, b) => {
+            const p = pair(a, b);
+            return p === undefined ? Infinity : r.dist[p[0] * r.n + p[1]];
+        },
+        path: (a, b) => {
+            const { pathTo, pathEdges } = r;
+            if (pathTo === undefined || pathEdges === undefined) {
+                // the same text the CPU result throws, so the message does not depend on the backend
+                throw new Error("allPairsShortestPath: pass paths: true to walk shortest paths");
+            }
+            const p = pair(a, b);
+            return p === undefined ? c.cy.collection() : pathOf(c, pathTo(p[0], p[1]), pathEdges(p[0], p[1]));
+        },
+    };
+}
+/**
+ * A PageRank result from scores.
+ * @param c - the context
+ * @param r - the run
+ * @returns the result
+ */
+function ranked(c, r) {
+    return scored(c, r.scores, { rank: accessor(c, r.scores), iterations: r.iterations, converged: r.converged });
+}
+/**
+ * A label-propagation partition. The GPU result has no `iterations` / `converged` (the WebGPU label propagation
+ * does not report them), so both are undefined when the GPU ran.
+ * @param c - the context
+ * @param r - the run
+ * @returns the partition
+ */
+function propagated(c, r) {
+    return partition(c, r.labels, { iterations: r.iterations, converged: r.converged });
+}
+/**
+ * The `topK` of a candidates method with the meaning it has on the prediction methods: a positive count keeps that
+ * many, 0 or less keeps every candidate (@graphty/algorithms slices with it, so 0 would keep none and -1 drop one).
+ * @param o - the options
+ * @param o.topK - the caller's value
+ * @returns the value for @graphty/algorithms
+ */
+function topK(o) {
+    return o.topK !== undefined && o.topK <= 0 ? Infinity : o.topK;
+}
+/**
+ * A matching result.
+ * @param c - the context
+ * @param r - the matching
+ * @param r.matching - partner per node index
+ * @param r.size - matched pairs
+ * @returns mate accessor and size
+ */
+function matched(c, r) {
+    const mate = new Uint32Array(c.s.nodeCount).fill(INVALID_INDEX);
+    r.matching.forEach((m, i) => {
+        if (m !== INVALID_INDEX) {
+            mate[i] = m;
+            mate[m] = i;
+        }
+    });
+    return {
+        size: r.size,
+        mate: (ref) => {
+            const i = lookup(c, ref);
+            return i === undefined || mate[i] === INVALID_INDEX ? undefined : c.cs.nodes[mate[i]];
+        },
+    };
+}
+/**
+ * The best level of a Girvan-Newman run.
+ * @param modularities - modularity per level
+ * @returns the level index with the highest modularity
+ */
+function bestLevel(modularities) {
+    let best = 0;
+    for (let k = 1; k < modularities.length; k++) {
+        if (modularities[k] > modularities[best]) {
+            best = k;
+        }
+    }
+    return best;
+}
+// ---------------------------------------------------------------------------------------------------------------
+// The algorithms. Key = the @graphty/algorithms name; registered as "graphty" + the key with a capital.
+const IMPLS = {
+    // Traversal and paths
+    breadthFirstSearch: (c, o) => {
+        const target = indexOf(c.cs, o.goal, `${c.name}: goal`);
+        return then(c.call("breadthFirstSearch", c.s, req(c, o.root, "root"), { ...c.rest, target }), (r) => search(c, r, target));
+    },
+    directionOptimizedBfs: (c, o) => search(c, directionOptimizedBfs(c.s, req(c, o.root, "root"), c.rest), undefined),
+    depthFirstSearch: (c, o) => {
+        const target = indexOf(c.cs, o.goal, `${c.name}: goal`);
+        // a post-order walk cannot stop at the goal, so it would silently visit every node
+        if (target !== undefined && o.order === "post") {
+            throw new Error(`${c.name}: goal stops only a pre-order walk; leave it out with order "post"`);
+        }
+        return search(c, depthFirstSearch(c.s, req(c, o.root, "root"), { ...c.rest, target }), target);
+    },
+    hasCycle: (c, _o = {}) => hasCycle(c.s),
+    topologicalSort: (c, _o = {}) => {
+        const order = topologicalSort(c.s);
+        return order === null ? null : nodesAt(c, order);
+    },
+    dijkstra: (c, o) => {
+        nonNegative(c);
+        return then(c.call("sssp", c.s, req(c, o.root, "root"), c.rest), (r) => paths(c, r));
+    },
+    bellmanFord: (c, o) => then(c.call("bellmanFord", c.s, req(c, o.root, "root"), c.rest), (r) => ({
+        ...paths(c, r),
+        hasNegativeWeightCycle: r.hasNegativeCycle,
+    })),
+    bidirectionalDijkstra: (c, o) => {
+        nonNegative(c);
+        const r = bidirectionalDijkstra(c.s, req(c, o.root, "root"), req(c, o.goal, "goal"), c.rest);
+        return { found: r.path.length > 0, distance: r.distance, path: pathOf(c, r.path, r.edges) };
+    },
+    aStar: (c, o) => {
+        const h = o.heuristic;
+        nonNegative(c);
+        const r = astar(c.s, req(c, o.root, "root"), req(c, o.goal, "goal"), h === undefined ? () => 0 : (u) => h(c.cs.nodes[u]), c.rest);
+        return { found: r.path.length > 0, distance: r.distance, path: pathOf(c, r.path, r.edges) };
+    },
+    allPairsShortestPath: (c, _o = {}) => then(c.call("allPairsShortestPath", c.s, c.rest), (r) => apsp(c, r)),
+    // Centrality
+    degreeCentrality: (c, _o = {}) => {
+        const v = degreeCentrality(c.s, c.rest);
+        return scored(c, v, { degree: accessor(c, v) });
+    },
+    degrees: (c, _o = {}) => {
+        const r = degrees(c.s);
+        if (!c.s.directed) {
+            // read both ways, an edge enters and leaves each end: both accessors give the degree (@graphty/algorithms'
+            // degrees counts by source and target whatever the direction)
+            const degree = Float64Array.from(r.inDegree, (d, i) => d + r.outDegree[i]);
+            return { indegree: accessor(c, degree), outdegree: accessor(c, degree) };
+        }
+        return { indegree: accessor(c, r.inDegree), outdegree: accessor(c, r.outDegree) };
+    },
+    pageRank: (c, o = {}) => {
+        const initialRanks = o.initialRanks && vectorOf(c, o.initialRanks, "initialRanks");
+        return then(c.call("pageRank", c.s, { ...c.rest, initialRanks, weighted: c.weighted }), (r) => ranked(c, r));
+    },
+    personalizedPageRank: (c, o) => {
+        const p = teleportOf(c, o.personalization);
+        const initialRanks = o.initialRanks && vectorOf(c, o.initialRanks, "initialRanks");
+        return then(c.call("personalizedPageRank", c.s, p, { ...c.rest, initialRanks, weighted: c.weighted }), (r) => ranked(c, r));
+    },
+    deltaPageRank: (c, o = {}) => {
+        // The engines keep state for `update()` over the same frozen snapshot; a changed Cytoscape graph is a new
+        // snapshot, so only the one-shot computation is offered.
+        const personalization = o.personalization === undefined ? undefined : teleportOf(c, o.personalization);
+        // PriorityDeltaPageRank's maxIterations counts processed nodes, so the pinned 100 rounds would stop it long
+        // before it converges on any but a tiny graph: without the caller's own budget it runs until no delta is left
+        const budget = o.priority === true && o.maxIterations === undefined ? { maxIterations: Infinity } : {};
+        const opts = { ...c.rest, ...budget, personalization, weighted: c.weighted };
+        const v = o.priority === true
+            ? new PriorityDeltaPageRank(c.s).computeWithPriority(opts)
+            : new DeltaPageRank(c.s).compute(opts);
+        // ponytail: @graphty/algorithms' DeltaPageRank overflows to NaN at a large maxIterations; refuse it here
+        // until that engine converges (then this check never fires)
+        if (v.some((x) => !Number.isFinite(x))) {
+            throw new RangeError(`${c.name}: the ranks overflowed (maxIterations ${String(c.rest.maxIterations)} is too high for this graph); ` +
+                "lower maxIterations, or pass priority: true");
+        }
+        return scored(c, v, { rank: accessor(c, v) });
+    },
+    eigenvectorCentrality: (c, o = {}) => {
+        const startVector = o.startVector && vectorOf(c, o.startVector, "startVector");
+        return then(c.call("eigenvectorCentrality", c.s, { ...c.rest, startVector }), (r) => scored(c, r.scores, { iterations: r.iterations, converged: r.converged }));
+    },
+    katzCentrality: (c, _o = {}) => then(c.call("katzCentrality", c.s, { ...c.rest, weighted: c.weighted }), (r) => scored(c, r.scores, { iterations: r.iterations, converged: r.converged })),
+    hits: (c, _o = {}) => then(c.call("hits", c.s, { ...c.rest, weighted: c.weighted }), (r) => scored(c, r.authorities, {
+        hub: accessor(c, r.hubs),
+        authority: accessor(c, r.authorities),
+        iterations: r.iterations,
+        converged: r.converged,
+    })),
+    closenessCentrality: (c, o = {}) => {
+        const sources = o.sources === undefined ? undefined : indicesOf(c.cs, o.sources);
+        return then(c.call("closenessCentrality", c.s, { ...c.rest, sources, weighted: c.weighted }), (r) => scored(c, r.scores, { closeness: accessor(c, r.scores) }));
+    },
+    nodeClosenessCentrality: (c, o) => nodeClosenessCentrality(c.s, req(c, o.root, "root"), { ...c.rest, weighted: c.weighted }),
+    betweennessCentrality: (c, o = {}) => {
+        const sources = o.sources === undefined ? undefined : indicesOf(c.cs, o.sources);
+        return then(c.call("betweennessCentrality", c.s, { ...c.rest, sources }), (r) => {
+            // Cytoscape's `betweenness` counts ordered pairs, so on an undirected graph it is twice the NetworkX
+            // convention `score` follows. The result does not say which scale it is in, so the factor is rebuilt here
+            // from the rules in @graphty/algorithms' BetweennessOptions.normalized.
+            const n = c.s.nodeCount;
+            const pairs = o.endpoints === true ? n * (n - 1) : (n - 1) * (n - 2);
+            const unordered = c.s.directed ? 1 : 2;
+            const toOrderedPairs = o.normalized === true && pairs > 0 ? pairs : unordered;
+            const raw = Float64Array.from(r.scores, (x) => x * toOrderedPairs);
+            const max = raw.reduce((m, x) => Math.max(m, x), 0);
+            return scored(c, r.scores, {
+                betweenness: accessor(c, raw),
+                betweennessNormalized: accessor(c, raw.map((x) => (max === 0 ? 0 : x / max))),
+            });
+        });
+    },
+    edgeBetweennessCentrality: (c, o = {}) => {
+        const sources = o.sources === undefined ? undefined : indicesOf(c.cs, o.sources);
+        return then(c.call("edgeBetweennessCentrality", c.s, { ...c.rest, sources }), (r) => scored(c, r.scores, {}, true));
+    },
+    // Components and structure
+    connectedComponents: (c, _o = {}) => then(c.call("connectedComponents", c.s), (r) => partition(c, r.labels, {})),
+    weaklyConnectedComponents: (c, _o = {}) => then(c.call("weaklyConnectedComponents", c.s), (r) => partition(c, r.labels, {})),
+    stronglyConnectedComponents: (c, _o = {}) => partition(c, stronglyConnectedComponents(c.s).labels, {}),
+    condensation: (c, _o = {}) => {
+        const r = condensation(c.s);
+        return partition(c, r.components.labels, { condensed: r.condensed });
+    },
+    kCoreDecomposition: (c, _o = {}) => {
+        const r = kCoreDecomposition(c.s);
+        const core = (k) => nodesAt(c, Array.from(r.coreness.keys()).filter((i) => r.coreness[i] >= k));
+        return scored(c, r.coreness, { maxCore: r.maxCore, core });
+    },
+    triangleCount: (c, _o = {}) => then(c.call("triangleCount", c.s), (r) => scored(c, r.perNode, {
+        coefficient: accessor(c, r.coefficient),
+        total: r.total,
+        transitivity: r.transitivity,
+    })),
+    isBipartite: (c, _o = {}) => {
+        const r = isBipartite(c.s, c.rest);
+        if (r.sides === null) {
+            const empty = c.cy.collection();
+            return { bipartite: false, partitionFirst: empty, partitionSecond: empty };
+        }
+        const { partitionFirst, partitionSecond } = cutOf(c, r.sides, [], 0);
+        return { bipartite: true, partitionFirst, partitionSecond };
+    },
+    isGraphIsomorphic: (c, o) => {
+        const other = otherOf(c, o);
+        const r = isGraphIsomorphic(c.s, other.snapshot, isoOptions(c, other, o));
+        const m = r.mapping;
+        return { isomorphic: r.isomorphic, mapping: m === null ? () => undefined : mapper(c, other, m) };
+    },
+    findAllIsomorphisms: (c, o) => {
+        const other = otherOf(c, o);
+        return findAllIsomorphisms(c.s, other.snapshot, isoOptions(c, other, o)).map((m) => mapper(c, other, m));
+    },
+    modularity: (c, o) => modularity(c.s, labelsOf(c, o.clusters, "clusters"), c.rest),
+    // Community detection and clustering
+    louvain: (c, _o = {}) => {
+        const r = louvain(c.s, c.rest);
+        return partition(c, r.labels, { modularity: r.modularity, iterations: r.iterations });
+    },
+    leiden: (c, _o = {}) => {
+        const r = leiden(c.s, c.rest);
+        return partition(c, r.labels, { modularity: r.modularity, iterations: r.iterations });
+    },
+    labelPropagation: (c, _o = {}) => then(c.call("labelPropagation", c.s, { ...c.rest, weighted: c.weighted }), (r) => propagated(c, r)),
+    labelPropagationSynchronous: (c, _o = {}) => then(c.call("labelPropagationSynchronous", c.s, { ...c.rest, weighted: c.weighted }), (r) => propagated(c, r)),
+    labelPropagationSemiSupervised: (c, o) => {
+        const r = labelPropagationSemiSupervised(c.s, labelsOf(c, o.seeds, "seeds"), {
+            ...c.rest,
+            weighted: c.weighted,
+        });
+        return partition(c, r.labels, { iterations: r.iterations, converged: r.converged });
+    },
+    girvanNewman: (c, _o = {}) => {
+        const r = girvanNewman(c.s, c.rest);
+        const quiet = { ...c, field: undefined };
+        const level = (k) => partition(quiet, r.levels[k] ?? [], {});
+        const best = bestLevel(r.modularity);
+        return partition(c, r.levels[best] ?? [], {
+            modularity: r.modularity[best] ?? Number.NaN,
+            levels: r.levels.length,
+            level,
+            modularities: Array.from(r.modularity),
+        });
+    },
+    markovClustering: (c, _o = {}) => {
+        const r = markovClustering(c.s, c.rest);
+        return partition(c, r.labels, { iterations: r.iterations, converged: r.converged });
+    },
+    spectralClustering: (c, o) => {
+        // required by the type, checked for callers without types
+        if (o.k === undefined) {
+            throw new Error(`${c.name}: the k option is required`);
+        }
+        const r = spectralClustering(c.s, c.rest);
+        return partition(c, r.labels, { converged: r.converged, eigenvalues: r.eigenvalues });
+    },
+    hierarchicalClustering: (c, _o = {}) => {
+        const r = hierarchicalClustering(c.s, c.rest);
+        const quiet = { ...c, field: undefined };
+        const cut = (h) => {
+            const labels = new Uint32Array(c.s.nodeCount).fill(INVALID_INDEX);
+            r.cut(h).forEach((group, k) => {
+                for (const i of group) {
+                    labels[i] = k;
+                }
+            });
+            return partition(quiet, labels, {});
+        };
+        const cutAt = (by) => partition(quiet, r.cutAt(by).labels, {});
+        return { merges: r.left.length, cut, cutAt };
+    },
+    teraHAC: (c, _o = {}) => {
+        const r = teraHAC(c.s, c.rest);
+        return partition(c, r.labels, { merges: r.merges });
+    },
+    grsbm: (c, _o = {}) => partition(c, grsbm(c.s, { ...c.rest, weighted: c.weighted }).labels, {}),
+    syncClustering: (c, o) => {
+        // required by the type, checked for callers without types
+        if (o.numClusters === undefined) {
+            throw new Error(`${c.name}: the numClusters option is required`);
+        }
+        const r = syncClustering(c.s, c.rest);
+        return partition(c, r.labels, { loss: r.loss, iterations: r.iterations, converged: r.converged });
+    },
+    // Spanning trees, flow, cuts, matching
+    kruskalMST: (c, _o = {}) => {
+        const r = kruskalMST(c.s);
+        return Object.assign(c.cs.nodes.union(edgesAt(c, r.edges)), { totalWeight: r.totalWeight });
+    },
+    primMST: (c, o = {}) => {
+        const start = indexOf(c.cs, o.root, `${c.name}: root`);
+        const r = primMST(c.s, { ...c.rest, start });
+        // a run that does not throw spans every node: the graph is connected, or `forest` grew a tree in every
+        // component (an isolated node is a tree of its own)
+        return Object.assign(c.cs.nodes.union(edgesAt(c, r.edges)), { totalWeight: r.totalWeight });
+    },
+    maxFlow: (c, o) => {
+        const r = maxFlow(c.s, req(c, o.source, "source"), req(c, o.sink, "sink"), c.rest);
+        return { ...cutOf(c, r.sourceSide, r.cutEdges, r.maxFlow), flow: accessor(c, r.flow, true) };
+    },
+    minSTCut: (c, o) => minCut(c, minSTCut(c.s, req(c, o.source, "source"), req(c, o.sink, "sink"), c.rest)),
+    stoerWagner: (c, _o = {}) => minCut(c, stoerWagner(c.s)),
+    kargerMinCut: (c, _o = {}) => minCut(c, kargerMinCut(c.s, c.rest)),
+    maximumBipartiteMatching: (c, o = {}) => matched(c, maximumBipartiteMatching(c.s, { ...c.rest, left: maskOf(c, o.left), right: maskOf(c, o.right) })),
+    greedyBipartiteMatching: (c, o = {}) => matched(c, greedyBipartiteMatching(c.s, { ...c.rest, left: maskOf(c, o.left), right: maskOf(c, o.right) })),
+    // Link prediction. `directed` also selects the directed score (out-neighbours of u against in-neighbours of v).
+    commonNeighborsScore: (c, o) => commonNeighborsScore(c.s, req(c, o.source, "source"), req(c, o.target, "target"), { directed: c.s.directed }),
+    adamicAdarScore: (c, o) => adamicAdarScore(c.s, req(c, o.source, "source"), req(c, o.target, "target"), { directed: c.s.directed }),
+    commonNeighborsPrediction: (c, _o = {}) => links(c, commonNeighborsPrediction(c.s, { ...c.rest, directed: c.s.directed, uniquePairs: true })),
+    adamicAdarPrediction: (c, _o = {}) => links(c, adamicAdarPrediction(c.s, { ...c.rest, directed: c.s.directed, uniquePairs: true })),
+    commonNeighborsForPairs: (c, o) => Array.from(commonNeighborsForPairs(c.s, pairsOf(c, o.pairs, "pairs"), { directed: c.s.directed })),
+    adamicAdarForPairs: (c, o) => Array.from(adamicAdarForPairs(c.s, pairsOf(c, o.pairs, "pairs"), { directed: c.s.directed })),
+    topCandidatesForNode: (c, o) => {
+        const candidates = o.candidates === undefined ? undefined : indicesOf(c.cs, o.candidates);
+        return links(c, getTopCandidatesForNode(c.s, req(c, o.root, "root"), {
+            ...c.rest,
+            topK: topK(o),
+            candidates,
+            directed: c.s.directed,
+        }));
+    },
+    topAdamicAdarCandidatesForNode: (c, o) => {
+        const candidates = o.candidates === undefined ? undefined : indicesOf(c.cs, o.candidates);
+        return links(c, getTopAdamicAdarCandidatesForNode(c.s, req(c, o.root, "root"), {
+            ...c.rest,
+            topK: topK(o),
+            candidates,
+            directed: c.s.directed,
+        }));
+    },
+    evaluateCommonNeighbors: (c, o) => evaluateCommonNeighbors(c.s, pairsOf(c, o.edges, "edges"), pairsOf(c, o.nonEdges, "nonEdges"), {
+        directed: c.s.directed,
+    }),
+    evaluateAdamicAdar: (c, o) => evaluateAdamicAdar(c.s, pairsOf(c, o.edges, "edges"), pairsOf(c, o.nonEdges, "nonEdges"), {
+        directed: c.s.directed,
+    }),
+    compareAdamicAdarWithCommonNeighbors: (c, o) => {
+        // both halves with `directed` (@graphty/algorithms' compareAdamicAdarWithCommonNeighbors drops it for the
+        // common-neighbors half), so each matches the method of its own name
+        const edges = pairsOf(c, o.edges, "edges");
+        const nonEdges = pairsOf(c, o.nonEdges, "nonEdges");
+        const opts = { directed: c.s.directed };
+        return {
+            adamicAdar: evaluateAdamicAdar(c.s, edges, nonEdges, opts),
+            commonNeighbors: evaluateCommonNeighbors(c.s, edges, nonEdges, opts),
+        };
+    },
+};
+/**
+ * The method name of an algorithm.
+ * @param key - the @graphty/algorithms name
+ * @returns "graphty" + the name with a capital
+ */
+function methodName(key) {
+    return `graphty${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+}
+/** Every synchronous method name `cytoscape.use(graphtyCytoscape)` registers on collections and the core. */
+export const ALGORITHM_NAMES = Object.keys(IMPLS).map(methodName);
+// The algorithms whose implementation goes through `c.call`, i.e. those the dispatcher can send to the GPU.
+const ASYNC_KEYS = [
+    "breadthFirstSearch",
+    "dijkstra",
+    "bellmanFord",
+    "allPairsShortestPath",
+    "pageRank",
+    "personalizedPageRank",
+    "eigenvectorCentrality",
+    "katzCentrality",
+    "hits",
+    "closenessCentrality",
+    "betweennessCentrality",
+    "edgeBetweennessCentrality",
+    "connectedComponents",
+    "weaklyConnectedComponents",
+    "triangleCount",
+    "labelPropagation",
+    "labelPropagationSynchronous",
+];
+/** Every `...Async` method name: the algorithms the WebGPU accelerator can run. */
+export const ASYNC_ALGORITHM_NAMES = ASYNC_KEYS.map((k) => `${methodName(k)}Async`);
+/**
+ * Runs one algorithm over a collection.
+ * @param eles - the collection
+ * @param key - the algorithm
+ * @param options - the caller's options
+ * @param algos - the CPU functions (a synchronous run) or the dispatcher (an asynchronous one)
+ * @returns the algorithm's result (a promise through the dispatcher) and the snapshot it ran on
+ */
+function run(eles, key, options, algos) {
+    const name = methodName(key);
+    // a Cytoscape built-in takes some arguments positionally (kruskal(weightFn)); one ignored here would run unweighted
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+        throw new TypeError(`${name}: takes one options object; pass a weight function as { weight: fn }`);
+    }
+    if (options.weight !== undefined && UNWEIGHTED.has(key)) {
+        throw new Error(`${name}: this algorithm reads no edge weights; remove the weight option`);
+    }
+    if (options.field !== undefined && NO_FIELD.has(key)) {
+        throw new Error(`${name}: this algorithm has no per-element value to write; remove the field option`);
+    }
+    const known = OPTION_NAMES[name] ?? [];
+    for (const [k, v] of Object.entries(options)) {
+        if (v !== undefined && !known.includes(k)) {
+            throw new Error(`${name}: unknown option ${k}; the options are ${known.join(", ")}`);
+        }
+    }
+    const directed = options.directed ?? DIRECTED.has(key);
+    // degree and eigenvector centrality read mode only on a directed graph; ignored, it would give total degree
+    const { mode } = options;
+    if ((mode === "in" || mode === "out") && !directed) {
+        throw new Error(`${name}: mode: "${mode}" needs directed: true`);
+    }
+    const cs = toSnapshot(eles, { directed, weight: options.weight });
+    const rest = {
+        ...DEFAULTS[key],
+        ...Object.fromEntries(Object.entries(options).filter(([k, v]) => !ADAPTER_KEYS.has(k) && v !== undefined)),
+    };
+    const c = {
+        name,
+        cy: coreOf(eles),
+        cs,
+        s: cs.snapshot,
+        field: options.field,
+        weighted: options.weight !== undefined,
+        rest,
+        call: (k, ...args) => algos[k](...args),
+    };
+    const fail = (error) => {
+        throw named(error, key);
+    };
+    let result;
+    try {
+        result = IMPLS[key](c, options);
+    }
+    catch (error) {
+        fail(error);
+    }
+    return { result: result instanceof Promise ? result.catch(fail) : result, snapshot: cs.snapshot };
+}
+/**
+ * An algorithm's error in a Cytoscape user's terms: it starts with the method name, and a graph of the wrong
+ * direction is told which option to change (the @graphty/algorithms message names its own functions and snapshot
+ * methods). The error object, its class and its `code` are kept.
+ * @param error - what the algorithm threw
+ * @param key - the algorithm
+ * @returns the error to throw
+ */
+function named(error, key) {
+    if (!(error instanceof Error)) {
+        return error;
+    }
+    const name = methodName(key);
+    const { code } = error;
+    if (code === "E_NEEDS_UNDIRECTED") {
+        const instead = key === "connectedComponents" ? ", or call graphtyWeaklyConnectedComponents" : "";
+        error.message = `${name}: needs an undirected graph; leave out directed: true${instead}`;
+    }
+    else if (code === "E_NEEDS_DIRECTED") {
+        error.message = `${name}: needs a directed graph; ${DIRECTED.has(key) ? "leave out directed: false" : "pass directed: true"}`;
+    }
+    else if (!error.message.startsWith(`${name}:`)) {
+        error.message = `${name}: ${error.message}`;
+    }
+    return error;
+}
+/**
+ * Runs an algorithm synchronously on the CPU.
+ * @param eles - the collection
+ * @param key - the algorithm
+ * @param options - the caller's options
+ * @returns the result
+ */
+function runSync(eles, key, options = {}) {
+    checkGpuMode(methodName(key), options?.gpu);
+    if (options.gpu === "require") {
+        const name = methodName(key);
+        throw new Error(ASYNC_KEYS.includes(key)
+            ? `${name}: runs on the CPU; call ${name}Async for the GPU`
+            : `${name}: has no GPU implementation and runs only on the CPU; leave out gpu: "require"`);
+    }
+    return run(eles, key, options, CPU).result;
+}
+/**
+ * Runs an algorithm through the @graphty/algorithms dispatcher, on the core's GPU when it has one, and reports
+ * which implementation answered. A GPU failure after the run started is thrown, never finished on the CPU.
+ * @param eles - the collection
+ * @param key - the algorithm
+ * @param options - the caller's options
+ * @returns the result with `backend`
+ */
+async function runAsync(eles, key, options = {}) {
+    checkGpuMode(`${methodName(key)}Async`, options?.gpu);
+    const cy = coreOf(eles);
+    const d = await gpuFor(cy, options.gpu);
+    // destroyed while the device was acquired: its device is disposed and its elements are gone with it
+    if (cy.destroyed()) {
+        throw coreDestroyedError();
+    }
+    const rec = d.gpu === null ? null : recording(d.gpu.accelerator);
+    warnIfFixable(d, eles.nodes().length);
+    const { result, snapshot } = run(eles, key, options, accelerated(rec?.accelerator ?? null));
+    // a data change during the run (another run writing its field, say) must not release what this run reads
+    const unhold = hold(snapshot);
+    let value;
+    try {
+        value = (await result);
+    }
+    catch (e) {
+        // destroyed mid-run, the device fails with "GpuContext is disposed"; the cause is the destroy
+        throw cy.destroyed() ? coreDestroyedError() : e;
+    }
+    finally {
+        unhold();
+        if (d.gpu !== null && typeof options.weight === "function") {
+            // a weight function bypasses the snapshot cache, so nothing else would release this upload
+            d.gpu.accelerator.release(snapshot);
+        }
+    }
+    const backend = backendOf(d, rec?.used() ?? false, "the options or the graph need the CPU implementation");
+    return Object.assign(value, { backend });
+}
+/**
+ * Registers every algorithm as a collection method and a core method named "graphty<Name>".
+ * @param cytoscape - the cytoscape function
+ */
+export function registerAlgorithms(cytoscape) {
+    for (const key of Object.keys(IMPLS)) {
+        const name = methodName(key);
+        cytoscape("collection", name, function (options) {
+            return runSync(this, key, options);
+        });
+        cytoscape("core", name, function (options) {
+            return runSync(this.elements(), key, options);
+        });
+    }
+    for (const key of ASYNC_KEYS) {
+        const name = `${methodName(key)}Async`;
+        cytoscape("collection", name, function (options) {
+            return runAsync(this, key, options);
+        });
+        cytoscape("core", name, function (options) {
+            return runAsync(this.elements(), key, options);
+        });
+    }
+}
+//# sourceMappingURL=algorithms.js.map