@sleetdrop/dsh-plugin-topology 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Read-only snapshot of the runtime plugin service dependency graph.
+ *
+ * `snapshot()` reads the live Cordis registry and reflect store and projects
+ * them into a JSON-safe bipartite graph without mutating the runtime. The
+ * graph carries the fiber tree (plugin parent pointers) alongside the
+ * inject/provide service edges, so the assembly hierarchy and the dependency
+ * topology are both visible in one capture. Isolation scopes are preserved as
+ * per-service scope discriminators, and a declared inject with no active
+ * provider is reported as unresolved instead of a dangling edge.
+ *
+ * The deep reads here reach into Cordis internals that are not part of its
+ * stable public API (`root.registry`, `root.reflect.store`, fiber fields).
+ * They are gated on a pinned `@deepseek-ai/cordis` peer range (see README
+ * "Compatibility"); a Cordis that reshapes these surfaces breaks this
+ * projection instead of degrading silently.
+ *
+ * @module @sleetdrop/dsh-plugin-topology
+ */
+import { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { Rankdir, RenderFormat, TopologyAnalysis, TopologyGraph } from './types.ts';
+export type * from './types.ts';
+export { analyzeGraph, collapse } from './metrics.ts';
+export { composeGraphvizSvgs, isolatedNodes, nodeLink, renderCompleteDot, renderDot, renderIsolatedDot, renderJson } from './render.ts';
+export type { NodeLinkEdge, NodeLinkGraph, NodeLinkNode } from './render.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        pluginTopology: PluginTopologyService;
+    }
+}
+/** Read-only projection of the runtime service dependency graph. */
+export declare class PluginTopologyService extends TypertRemoteService {
+    private graphvizPromise;
+    constructor(ctx: Context);
+    /**
+     * Capture the current runtime topology without mutating it.
+     * @returns a JSON-safe bipartite graph of plugins and services.
+     */
+    snapshot(): TopologyGraph;
+    /**
+     * Capture the runtime topology and derive its graph-theory analysis.
+     * @returns the bipartite snapshot, its collapsed projection, and metrics.
+     */
+    analyze(): TopologyAnalysis;
+    /**
+     * Export the current topology in one serialized format.
+     * @param format - `json` (node-link document), `dot` (Graphviz source), or `svg` (Graphviz-rendered SVG).
+     * @param rankdir - Graphviz layout direction for `dot`/`svg`; ignored by `json`.
+     * @returns the serialized document for the format.
+     */
+    render(format: RenderFormat, rankdir: Rankdir): Promise<string>;
+}
+export default PluginTopologyService;

package/lib/index.js

@@ -0,0 +1,198 @@
+/**
+ * Read-only snapshot of the runtime plugin service dependency graph.
+ *
+ * `snapshot()` reads the live Cordis registry and reflect store and projects
+ * them into a JSON-safe bipartite graph without mutating the runtime. The
+ * graph carries the fiber tree (plugin parent pointers) alongside the
+ * inject/provide service edges, so the assembly hierarchy and the dependency
+ * topology are both visible in one capture. Isolation scopes are preserved as
+ * per-service scope discriminators, and a declared inject with no active
+ * provider is reported as unresolved instead of a dangling edge.
+ *
+ * The deep reads here reach into Cordis internals that are not part of its
+ * stable public API (`root.registry`, `root.reflect.store`, fiber fields).
+ * They are gated on a pinned `@deepseek-ai/cordis` peer range (see README
+ * "Compatibility"); a Cordis that reshapes these surfaces breaks this
+ * projection instead of degrading silently.
+ *
+ * @module @sleetdrop/dsh-plugin-topology
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Context } from '@deepseek-ai/cordis';
+import { Graphviz } from '@hpcc-js/wasm-graphviz';
+import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { analyzeGraph } from "./metrics.js";
+import { composeGraphvizSvgs, isolatedNodes, renderCompleteDot, renderDot, renderIsolatedDot, renderJson } from "./render.js";
+export { analyzeGraph, collapse } from "./metrics.js";
+export { composeGraphvizSvgs, isolatedNodes, nodeLink, renderCompleteDot, renderDot, renderIsolatedDot, renderJson } from "./render.js";
+/** Map a Cordis fiber state number to its stable name. */
+function fiberStateName(state) {
+    switch (state) {
+        case 0: return 'PENDING';
+        case 1: return 'LOADING';
+        case 2: return 'ACTIVE';
+        case 3: return 'FAILED';
+        case 4: return 'DISPOSED';
+        default: return 'UNLOADING';
+    }
+}
+/** Read-only projection of the runtime service dependency graph. */
+let PluginTopologyService = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _analyze_decorators;
+    let _render_decorators;
+    return class PluginTopologyService extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _analyze_decorators = [Remote('analyze')];
+            _render_decorators = [Remote('render')];
+            __esDecorate(this, null, _analyze_decorators, { kind: "method", name: "analyze", static: false, private: false, access: { has: obj => "analyze" in obj, get: obj => obj.analyze }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _render_decorators, { kind: "method", name: "render", static: false, private: false, access: { has: obj => "render" in obj, get: obj => obj.render }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        graphvizPromise = __runInitializers(this, _instanceExtraInitializers);
+        constructor(ctx) {
+            super(ctx, 'pluginTopology');
+        }
+        /**
+         * Capture the current runtime topology without mutating it.
+         * @returns a JSON-safe bipartite graph of plugins and services.
+         */
+        snapshot() {
+            const root = this.ctx.root;
+            const nodes = [];
+            const edges = [];
+            const unresolved = [];
+            const fiberIds = new Map();
+            // Plugin nodes. The root fiber is not registered, so synthesize it to root
+            // the fiber tree; its uid is 0 by construction.
+            nodes.push({ id: 'p:0', kind: 'plugin', label: 'root', state: 'ACTIVE', parent: null, inject: [] });
+            for (const runtime of root.registry.values()) {
+                for (const fiber of runtime.fibers) {
+                    const uid = fiber.uid;
+                    if (uid === null)
+                        continue;
+                    const id = `p:${uid}`;
+                    fiberIds.set(fiber, id);
+                    const parentUid = fiber.parent.fiber.uid;
+                    // Loader-mounted fibers carry the module specifier they were imported
+                    // from (the npm/package path); programmatic mounts do not.
+                    const source = fiber.entry?.options?.name;
+                    nodes.push({
+                        id,
+                        kind: 'plugin',
+                        label: fiber.name,
+                        state: fiberStateName(fiber.state),
+                        parent: parentUid === null ? null : `p:${parentUid}`,
+                        inject: Object.keys(fiber.inject),
+                        ...(source === undefined ? {} : { source }),
+                    });
+                }
+            }
+            // Service nodes and provides edges. Store keys are isolation labels.
+            const implIds = new Map();
+            const scopeIds = new Map();
+            let isolateCounter = 0;
+            for (const key of Object.getOwnPropertySymbols(root.reflect.store)) {
+                const impl = root.reflect.store[key];
+                if (impl === undefined)
+                    continue;
+                let scope = scopeIds.get(key);
+                if (scope === undefined) {
+                    scope = key === root[Context.isolate][impl.name] ? 'root' : `isolate-${isolateCounter++}`;
+                    scopeIds.set(key, scope);
+                }
+                const serviceId = `s:${scope}:${impl.name}`;
+                implIds.set(impl, serviceId);
+                nodes.push({ id: serviceId, kind: 'service', label: impl.name, scope });
+                const providerId = fiberIds.get(impl.fiber);
+                if (providerId !== undefined) {
+                    edges.push({ source: providerId, target: serviceId, kind: 'provides', service: impl.name });
+                }
+            }
+            // Inject edges, or unresolved declarations for dependencies with no active provider.
+            for (const [fiber, id] of fiberIds) {
+                for (const name of Object.keys(fiber.inject)) {
+                    const impl = fiber.store?.[name];
+                    if (impl === undefined) {
+                        unresolved.push({ plugin: id, service: name, state: fiberStateName(fiber.state) });
+                        continue;
+                    }
+                    const serviceId = implIds.get(impl);
+                    if (serviceId !== undefined) {
+                        edges.push({ source: serviceId, target: id, kind: 'injects', service: name });
+                    }
+                }
+            }
+            return {
+                kind: 'bipartite',
+                generatedAt: new Date().toISOString(),
+                nodes,
+                edges,
+                unresolved,
+            };
+        }
+        /**
+         * Capture the runtime topology and derive its graph-theory analysis.
+         * @returns the bipartite snapshot, its collapsed projection, and metrics.
+         */
+        analyze() {
+            return analyzeGraph(this.snapshot());
+        }
+        /**
+         * Export the current topology in one serialized format.
+         * @param format - `json` (node-link document), `dot` (Graphviz source), or `svg` (Graphviz-rendered SVG).
+         * @param rankdir - Graphviz layout direction for `dot`/`svg`; ignored by `json`.
+         * @returns the serialized document for the format.
+         */
+        async render(format, rankdir) {
+            const analysis = this.analyze();
+            if (format === 'json')
+                return renderJson(analysis);
+            if (format === 'dot')
+                return renderCompleteDot(analysis, rankdir);
+            const graphviz = await (this.graphvizPromise ??= Graphviz.load());
+            const mainSvg = graphviz.dot(renderDot(analysis, rankdir), 'svg');
+            if (isolatedNodes(analysis).length === 0)
+                return mainSvg;
+            const isolatedSvg = graphviz.dot(renderIsolatedDot(analysis, rankdir), 'svg');
+            return composeGraphvizSvgs(mainSvg, isolatedSvg, rankdir);
+        }
+    };
+})();
+export { PluginTopologyService };
+export default PluginTopologyService;

package/lib/invariant.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Package-owned invariant companion.
+ * @module @sleetdrop/dsh-plugin-topology/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "plugin-topology-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;

package/lib/invariant.js

@@ -0,0 +1,17 @@
+/**
+ * Package-owned invariant companion.
+ * @module @sleetdrop/dsh-plugin-topology/invariant
+ */
+const PACKAGE_NAME = '@sleetdrop/dsh-plugin-topology';
+/** Cordis companion plugin name. */
+export const name = 'plugin-topology-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/** No runtime invariant: this package owns a read-only diagnostic surface. */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));

package/lib/metrics.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Graph-theory analysis of the plugin topology snapshot.
+ *
+ * `collapse` projects the bipartite service graph onto plugin-to-plugin
+ * `depends-on` edges (a plugin depends on the plugin that provides each
+ * service it injects). `computeMetrics` derives degree, centrality, and
+ * connectivity metrics from that projection; `analyzeGraph` composes both.
+ *
+ * Metrics run on the collapsed plugin graph with service-mediated repeats
+ * deduplicated, so `edgeCount` counts unique dependency pairs rather than
+ * service edges. Eigenvector centrality is 0 on an acyclic graph by
+ * definition; PageRank, betweenness, degree, and connectivity stay meaningful.
+ *
+ * @module @sleetdrop/dsh-plugin-topology/metrics
+ */
+import type { CollapsedGraph, GraphMetrics, NodeMetrics, TopologyAnalysis, TopologyGraph } from './types.ts';
+export type * from './types.ts';
+/** Project the bipartite graph onto plugin-to-plugin `depends-on` edges. */
+export declare function collapse(graph: TopologyGraph): CollapsedGraph;
+/** Derive per-node and aggregate metrics from a collapsed graph. */
+export declare function computeMetrics(collapsed: CollapsedGraph): {
+    nodeMetrics: Record<string, NodeMetrics>;
+    graphMetrics: GraphMetrics;
+};
+/** Compose the collapsed projection and its metrics into one analysis. */
+export declare function analyzeGraph(graph: TopologyGraph): TopologyAnalysis;

package/lib/metrics.js

@@ -0,0 +1,331 @@
+/**
+ * Graph-theory analysis of the plugin topology snapshot.
+ *
+ * `collapse` projects the bipartite service graph onto plugin-to-plugin
+ * `depends-on` edges (a plugin depends on the plugin that provides each
+ * service it injects). `computeMetrics` derives degree, centrality, and
+ * connectivity metrics from that projection; `analyzeGraph` composes both.
+ *
+ * Metrics run on the collapsed plugin graph with service-mediated repeats
+ * deduplicated, so `edgeCount` counts unique dependency pairs rather than
+ * service edges. Eigenvector centrality is 0 on an acyclic graph by
+ * definition; PageRank, betweenness, degree, and connectivity stay meaningful.
+ *
+ * @module @sleetdrop/dsh-plugin-topology/metrics
+ */
+/** Index a parallel array; the index is in bounds by construction. */
+function at(array, index) {
+    const value = array[index];
+    if (value === undefined) {
+        throw new Error(`index ${index} is out of bounds for an array of length ${array.length}`);
+    }
+    return value;
+}
+/** Pop from a non-empty stack. */
+function pop(stack) {
+    const value = stack.pop();
+    if (value === undefined) {
+        throw new Error('pop from an empty stack');
+    }
+    return value;
+}
+/** Project the bipartite graph onto plugin-to-plugin `depends-on` edges. */
+export function collapse(graph) {
+    const pluginNodes = graph.nodes.filter(node => node.kind === 'plugin');
+    const providers = new Map();
+    const consumers = new Map();
+    for (const edge of graph.edges) {
+        if (edge.kind === 'provides') {
+            providers.set(edge.target, { plugin: edge.source, service: edge.service });
+        }
+        else {
+            let set = consumers.get(edge.source);
+            if (set === undefined) {
+                set = new Set();
+                consumers.set(edge.source, set);
+            }
+            set.add(edge.target);
+        }
+    }
+    const edges = [];
+    for (const [serviceId, { plugin, service }] of providers) {
+        const consumerSet = consumers.get(serviceId);
+        if (consumerSet === undefined)
+            continue;
+        for (const consumer of consumerSet) {
+            edges.push({ source: consumer, target: plugin, service });
+        }
+    }
+    return { kind: 'collapsed', generatedAt: graph.generatedAt, nodes: pluginNodes, edges };
+}
+/** Derive per-node and aggregate metrics from a collapsed graph. */
+export function computeMetrics(collapsed) {
+    const nodeIds = collapsed.nodes.map(node => node.id).sort();
+    const n = nodeIds.length;
+    const index = new Map();
+    nodeIds.forEach((id, i) => index.set(id, i));
+    const out = Array.from({ length: n }, () => new Set());
+    const inc = Array.from({ length: n }, () => new Set());
+    for (const edge of collapsed.edges) {
+        const source = index.get(edge.source);
+        const target = index.get(edge.target);
+        if (source === undefined || target === undefined)
+            continue;
+        at(out, source).add(target);
+        at(inc, target).add(source);
+    }
+    const outDegree = out.map(set => set.size);
+    const inDegree = inc.map(set => set.size);
+    const components = tarjan(out);
+    const componentSize = new Map();
+    for (const component of components) {
+        componentSize.set(component, (componentSize.get(component) ?? 0) + 1);
+    }
+    const stronglyConnectedComponents = componentSize.size;
+    let largestSccSize = 0;
+    for (const size of componentSize.values()) {
+        if (size > largestSccSize)
+            largestSccSize = size;
+    }
+    const { diameter, averagePathLength } = shortestPaths(out);
+    const weaklyConnectedComponents = countWeakComponents(out);
+    const betweenness = brandes(out);
+    const eigenvector = eigenvectorCentrality(inc);
+    const rank = pagerank(inc, outDegree);
+    const uniqueEdges = out.reduce((sum, set) => sum + set.size, 0);
+    const density = n <= 1 ? 0 : uniqueEdges / (n * (n - 1));
+    const nodeMetrics = {};
+    for (let i = 0; i < n; i++) {
+        nodeMetrics[at(nodeIds, i)] = {
+            inDegree: at(inDegree, i),
+            outDegree: at(outDegree, i),
+            degreeCentrality: n <= 1 ? 0 : (at(inDegree, i) + at(outDegree, i)) / (2 * (n - 1)),
+            betweennessCentrality: at(betweenness, i),
+            eigenvectorCentrality: at(eigenvector, i),
+            pagerank: at(rank, i),
+        };
+    }
+    return {
+        nodeMetrics,
+        graphMetrics: {
+            nodeCount: n,
+            edgeCount: uniqueEdges,
+            density,
+            stronglyConnectedComponents,
+            largestSccSize,
+            isDag: stronglyConnectedComponents === n,
+            weaklyConnectedComponents,
+            diameter,
+            averagePathLength,
+            sourceCount: outDegree.filter(degree => degree === 0).length,
+            sinkCount: inDegree.filter(degree => degree === 0).length,
+        },
+    };
+}
+/** Compose the collapsed projection and its metrics into one analysis. */
+export function analyzeGraph(graph) {
+    const collapsed = collapse(graph);
+    const { nodeMetrics, graphMetrics } = computeMetrics(collapsed);
+    return { graph, collapsed, nodeMetrics, graphMetrics };
+}
+/** Tarjan strongly connected components over the `depends-on` adjacency. */
+function tarjan(out) {
+    const n = out.length;
+    const index = new Array(n).fill(-1);
+    const low = new Array(n).fill(-1);
+    const onStack = new Array(n).fill(false);
+    const stack = [];
+    const component = new Array(n).fill(-1);
+    let counter = 0;
+    let componentCount = 0;
+    const visit = (v) => {
+        index[v] = low[v] = counter++;
+        stack.push(v);
+        onStack[v] = true;
+        for (const w of at(out, v)) {
+            if (at(index, w) === -1) {
+                visit(w);
+                low[v] = Math.min(at(low, v), at(low, w));
+            }
+            else if (at(onStack, w)) {
+                low[v] = Math.min(at(low, v), at(index, w));
+            }
+        }
+        if (at(low, v) === at(index, v)) {
+            let w;
+            do {
+                w = pop(stack);
+                onStack[w] = false;
+                component[w] = componentCount;
+            } while (w !== v);
+            componentCount++;
+        }
+    };
+    for (let v = 0; v < n; v++) {
+        if (at(index, v) === -1)
+            visit(v);
+    }
+    return component;
+}
+/** Directed all-pairs shortest paths; unreachable pairs are excluded. */
+function shortestPaths(out) {
+    const n = out.length;
+    let diameter = 0;
+    let total = 0;
+    let count = 0;
+    for (let source = 0; source < n; source++) {
+        const distance = new Array(n).fill(-1);
+        distance[source] = 0;
+        const queue = [source];
+        let head = 0;
+        while (head < queue.length) {
+            const v = at(queue, head);
+            head++;
+            for (const w of at(out, v)) {
+                if (at(distance, w) === -1) {
+                    distance[w] = at(distance, v) + 1;
+                    queue.push(w);
+                }
+            }
+        }
+        for (let target = 0; target < n; target++) {
+            const d = at(distance, target);
+            if (target === source || d < 0)
+                continue;
+            total += d;
+            count++;
+            if (d > diameter)
+                diameter = d;
+        }
+    }
+    return { diameter, averagePathLength: count === 0 ? 0 : total / count };
+}
+/** Number of weakly connected components on the undirected projection. */
+function countWeakComponents(out) {
+    const n = out.length;
+    const undirected = Array.from({ length: n }, () => new Set());
+    for (let v = 0; v < n; v++) {
+        for (const w of at(out, v)) {
+            at(undirected, v).add(w);
+            at(undirected, w).add(v);
+        }
+    }
+    const visited = new Array(n).fill(false);
+    let components = 0;
+    for (let start = 0; start < n; start++) {
+        if (at(visited, start))
+            continue;
+        components++;
+        const queue = [start];
+        visited[start] = true;
+        let head = 0;
+        while (head < queue.length) {
+            const v = at(queue, head);
+            head++;
+            for (const w of at(undirected, v)) {
+                if (at(visited, w))
+                    continue;
+                visited[w] = true;
+                queue.push(w);
+            }
+        }
+    }
+    return components;
+}
+/** Brandes unweighted directed betweenness centrality. */
+function brandes(out) {
+    const n = out.length;
+    const centrality = new Array(n).fill(0);
+    for (let source = 0; source < n; source++) {
+        const stack = [];
+        const predecessors = Array.from({ length: n }, () => []);
+        const sigma = new Array(n).fill(0);
+        const distance = new Array(n).fill(-1);
+        sigma[source] = 1;
+        distance[source] = 0;
+        const queue = [source];
+        let head = 0;
+        while (head < queue.length) {
+            const v = at(queue, head);
+            head++;
+            stack.push(v);
+            for (const w of at(out, v)) {
+                if (at(distance, w) === -1) {
+                    distance[w] = at(distance, v) + 1;
+                    queue.push(w);
+                }
+                if (at(distance, w) === at(distance, v) + 1) {
+                    sigma[w] = at(sigma, w) + at(sigma, v);
+                    at(predecessors, w).push(v);
+                }
+            }
+        }
+        const dependency = new Array(n).fill(0);
+        while (stack.length > 0) {
+            const w = pop(stack);
+            for (const v of at(predecessors, w)) {
+                dependency[v] = at(dependency, v) + (at(sigma, v) / at(sigma, w)) * (1 + at(dependency, w));
+            }
+            if (w !== source)
+                centrality[w] = at(centrality, w) + at(dependency, w);
+        }
+    }
+    return centrality;
+}
+/** Power-iteration eigenvector centrality from in-neighbors. */
+function eigenvectorCentrality(inc) {
+    const n = inc.length;
+    if (n === 0)
+        return [];
+    let x = new Array(n).fill(1 / Math.sqrt(n));
+    for (let iteration = 0; iteration < 100; iteration++) {
+        const next = new Array(n).fill(0);
+        for (let i = 0; i < n; i++) {
+            for (const j of at(inc, i)) {
+                next[i] = at(next, i) + at(x, j);
+            }
+        }
+        const norm = Math.sqrt(next.reduce((sum, value) => sum + value * value, 0));
+        if (norm === 0)
+            return new Array(n).fill(0);
+        let delta = 0;
+        for (let i = 0; i < n; i++) {
+            next[i] = at(next, i) / norm;
+            delta += Math.abs(at(next, i) - at(x, i));
+        }
+        x = next;
+        if (delta < 1e-9)
+            break;
+    }
+    return x;
+}
+/** PageRank from in-neighbors with damping 0.85. */
+function pagerank(inc, outDegree) {
+    const n = inc.length;
+    if (n === 0)
+        return [];
+    const damping = 0.85;
+    let x = new Array(n).fill(1 / n);
+    for (let iteration = 0; iteration < 100; iteration++) {
+        const next = new Array(n).fill((1 - damping) / n);
+        let dangling = 0;
+        for (let j = 0; j < n; j++) {
+            if (at(outDegree, j) === 0)
+                dangling += at(x, j);
+        }
+        for (let i = 0; i < n; i++) {
+            for (const j of at(inc, i)) {
+                next[i] = at(next, i) + (damping * at(x, j)) / at(outDegree, j);
+            }
+            next[i] = at(next, i) + (damping * dangling) / n;
+        }
+        let delta = 0;
+        for (let i = 0; i < n; i++) {
+            delta += Math.abs(at(next, i) - at(x, i));
+        }
+        x = next;
+        if (delta < 1e-9)
+            break;
+    }
+    return x;
+}