@graphty/graphty-element 2.5.2 → 2.6.0

package/dist/src/algorithms/Algorithm.d.ts

@@ -1,11 +1,13 @@
 import { type AcceleratedAlgorithms, type Graph as AlgorithmGraph } from "@graphty/algorithms";
 import { type GraphSnapshot, type U32 } from "@graphty/graph-format";
 import { type AccelerationPrecision } from "../acceleration/types";
-import type { AlgorithmDescriptor, FieldDescriptor, NodeId } from "../catalog/types";
+import type { AlgorithmDescriptor, EdgeId, FieldDescriptor, NodeId } from "../catalog/types";
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
 import { Graph } from "../Graph";
 import type { RunResult } from "../session/results";
-import type { AlgorithmRunContext } from "./results/types";
+import type { InputOrientation, SimplifyPolicy } from "./input/derivedInputs";
+import { type ElementScopedInput, type ScopedInputOptions, type ScopeInputDeclaration } from "./input/ScopedInput";
+import type { RunControls } from "./results/types";
 import { type OptionsSchema } from "./types/OptionSchema";
 import { type AlgorithmGraphMode } from "./utils/snapshotGraph";
 /**
@@ -73,6 +75,11 @@ export interface AlgorithmStatics {
      * and nothing at all identifying the code that actually did the work.
      */
     version?: string;
+    /**
+     * What a run over a scope computes on. See {@link Algorithm.scopeInput}; `register` publishes
+     * it as the descriptor's `scopeInput`.
+     */
+    scopeInput?: ScopeInputDeclaration;
     optionsSchema: OptionsSchema;
     /** @deprecated Use getZodOptionsSchema() instead */
     getOptionsSchema(): OptionsSchema;
@@ -104,7 +111,8 @@ export interface AcceleratedAlgorithmRun {
      * The snapshot the work runs over: the declared one for `"directed"`, the undirected view for
      * `"undirected"`, in either case with every group of parallel edges collapsed to one edge
      * carrying the group's summed weight. Its `ids` map is how a node id becomes the index every
-     * result is keyed by, and the node space is the declared one either way.
+     * result is keyed by: the declared node space for the whole graph, the scope's compact one
+     * for an algorithm that declares a scoped input.
      */
     readonly snapshot: GraphSnapshot;
     /**
@@ -178,6 +186,26 @@ export declare abstract class Algorithm<TOptions extends Record<string, unknown>
      * This is the new unified system that provides both validation and UI metadata.
      */
     static zodOptionsSchema?: ZodOptionsSchema;
+    /**
+     * Whether this algorithm computes over its run's scope. `"subgraph"`: the run context's
+     * `input` hands the algorithm its scope (the compact snapshot, and the scope's masks over the
+     * full graph), and the planner estimates the run over the scope. Absent or `"none"`: the whole
+     * graph, of whose values the element keeps the scope's, with a caveat saying so; the planner
+     * estimates and refuses the run as a whole-graph one.
+     *
+     * THE ONE DECLARATION: the input, the caveat and the published `descriptor.scopeInput` all
+     * read it. Declare it only once every node list, edge read and count the class takes comes
+     * from the input, because an algorithm that lists its nodes some other way would compute over
+     * a scoped topology while reporting every node.
+     */
+    static scopeInput?: ScopeInputDeclaration;
+    /**
+     * How this class's input merges a group of parallel edges into one: `"sum"` when absent, the
+     * element's reading of a repeated edge as more connection. A shortest path wants `"min"`, the
+     * cheapest of the group. Both seams read it, and the run's caveat names it.
+     * @internal
+     */
+    static parallelEdges?: SimplifyPolicy;
     protected graph: Graph;
     /**
      * Resolved options for this algorithm instance
@@ -217,6 +245,26 @@ export declare abstract class Algorithm<TOptions extends Record<string, unknown>
      * @returns a freshly built Graph for the algorithm package
      */
     protected algorithmGraph(mode: AlgorithmGraphMode): AlgorithmGraph;
+    /**
+     * The graph this run computes over, in one orientation: its scope's compact snapshot when the
+     * class declares {@link Algorithm.scopeInput} and runs as a run, else the whole graph. Both
+     * seams below read through it.
+     * @param orientation - `"declared"` or `"undirected"`.
+     * @param options - How parallel edges merge; the class's {@link Algorithm.parallelEdges} by
+     *   default, else `"sum"`.
+     * @returns The input.
+     * @internal
+     */
+    protected input(orientation: InputOrientation, options?: ScopedInputOptions): ElementScopedInput;
+    /**
+     * One edge's record, by the id an input named it by: for an attribute the snapshot does not
+     * carry yet, such as a flow capacity. It is not a topology read -- the ids come from the input
+     * -- and it goes away once the store carries attribute columns.
+     * @param id - The edge's session id, from `scopeEdges`.
+     * @returns The record the edge was loaded from, or undefined.
+     * @internal
+     */
+    protected edgeRecord(id: EdgeId): Readonly<Record<string, unknown>> | undefined;
     /**
      * The route an algorithm with an accelerated implementation takes.
      *
@@ -295,7 +343,7 @@ export declare abstract class Algorithm<TOptions extends Record<string, unknown>
      * @throws A `GraphtyError` with code `E_UNSUPPORTED` when this algorithm has no result to
      *   publish.
      */
-    publishResult(_context: AlgorithmRunContext, runId: string, _fields?: readonly FieldDescriptor[]): Promise<RunResult | undefined>;
+    publishResult(_context: RunControls, runId: string, _fields?: readonly FieldDescriptor[]): Promise<RunResult | undefined>;
     /**
      * Registers an algorithm class in the global registry
      * @param cls - The algorithm class to register

package/dist/src/algorithms/BFSAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import { type OptionsSchema } from "./types/OptionSchema";
 /**
@@ -19,6 +20,8 @@ interface BFSOptions extends Record<string, unknown> {
 export declare class BFSAlgorithm extends DeclaredAlgorithm<BFSOptions> {
     static namespace: string;
     static type: string;
+    /** Walks the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     /**
      * Options schema for BFS algorithm

package/dist/src/algorithms/BellmanFordAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import type { OptionsSchema } from "./types/OptionSchema";
 /**
@@ -17,6 +18,8 @@ interface BellmanFordOptions extends Record<string, unknown> {
 export declare class BellmanFordAlgorithm extends DeclaredAlgorithm<BellmanFordOptions> {
     static namespace: string;
     static type: string;
+    /** Searches the run's scope: the node and edge lists and the graph all come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/BetweennessCentralityAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import type { FieldDescriptor, NodeId } from "../catalog/types";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { MetricAlgorithm } from "./metrics/MetricAlgorithm";
 import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 /**
@@ -11,6 +12,8 @@ import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 export declare class BetweennessCentralityAlgorithm extends MetricAlgorithm {
     static namespace: string;
     static type: string;
+    /** Computes over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * The fields a betweenness result publishes.
      * @returns The uniform node-metric fields.

package/dist/src/algorithms/BipartiteMatchingAlgorithm.d.ts

@@ -5,6 +5,7 @@
  * A matching is a set of edges without common vertices.
  * Maximum matching has the largest possible number of edges.
  */
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 /**
  * Bipartite Matching algorithm for finding maximum matchings
@@ -15,6 +16,8 @@ import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } fro
 export declare class BipartiteMatchingAlgorithm extends DeclaredAlgorithm {
     static namespace: string;
     static type: string;
+    /** Pairs within the run's scope: the edge list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * Pair up the two sides of a two-sided graph so that as many nodes as possible get a partner.
      *

package/dist/src/algorithms/ClosenessCentralityAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import type { FieldDescriptor, NodeId } from "../catalog/types";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { MetricAlgorithm } from "./metrics/MetricAlgorithm";
 import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 /**
@@ -10,6 +11,8 @@ import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 export declare class ClosenessCentralityAlgorithm extends MetricAlgorithm {
     static namespace: string;
     static type: string;
+    /** Computes over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * The fields a closeness result publishes.
      * @returns The uniform node-metric fields.

package/dist/src/algorithms/ConnectedComponentsAlgorithm.d.ts

@@ -1,10 +1,13 @@
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 /**
- *
+ * Connected components: the separate pieces of the graph, or of the run's scope.
  */
 export declare class ConnectedComponentsAlgorithm extends DeclaredAlgorithm {
     static namespace: string;
     static type: string;
+    /** Groups over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * Find the separate pieces of the graph.
      *

package/dist/src/algorithms/DFSAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import { type OptionsSchema } from "./types/OptionSchema";
 /**
@@ -23,6 +24,8 @@ interface DFSOptions extends Record<string, unknown> {
 export declare class DFSAlgorithm extends DeclaredAlgorithm<DFSOptions> {
     static namespace: string;
     static type: string;
+    /** Walks the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     /**
      * Options schema for DFS algorithm

package/dist/src/algorithms/DegreeAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import type { FieldDescriptor, NodeId } from "../catalog/types";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { MetricAlgorithm } from "./metrics/MetricAlgorithm";
 import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 /**
@@ -11,6 +12,8 @@ import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 export declare class DegreeAlgorithm extends MetricAlgorithm {
     static namespace: string;
     static type: string;
+    /** Counts over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * The fields a degree result publishes.
      * @returns The uniform node-metric fields, plus `inDegree` and `outDegree`.

package/dist/src/algorithms/DijkstraAlgorithm.d.ts

@@ -1,4 +1,6 @@
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import type { SimplifyPolicy } from "./input/derivedInputs";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import { type OptionsSchema } from "./types/OptionSchema";
 /**
@@ -21,6 +23,10 @@ interface DijkstraOptions extends Record<string, unknown> {
 export declare class DijkstraAlgorithm extends DeclaredAlgorithm<DijkstraOptions> {
     static namespace: string;
     static type: string;
+    /** Searches the run's scope: the node and edge lists and the graph all come from the input. */
+    static scopeInput: ScopeInputDeclaration;
+    /** A route takes the cheapest of a group of parallel edges, not their sum. */
+    static parallelEdges: SimplifyPolicy;
     static zodOptionsSchema: ZodOptionsSchema;
     /**
      * Options schema for Dijkstra algorithm

package/dist/src/algorithms/EigenvectorCentralityAlgorithm.d.ts

@@ -1,5 +1,6 @@
 import type { FieldDescriptor, NodeId } from "../catalog/types";
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { MetricAlgorithm } from "./metrics/MetricAlgorithm";
 import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 import type { OptionsSchema } from "./types/OptionSchema";
@@ -29,6 +30,7 @@ interface EigenvectorCentralityOptions extends Record<string, unknown> {
 export declare class EigenvectorCentralityAlgorithm extends MetricAlgorithm<EigenvectorCentralityOptions> {
     static namespace: string;
     static type: string;
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/FloydWarshallAlgorithm.d.ts

@@ -1,3 +1,4 @@
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 /**
  *
@@ -5,6 +6,8 @@ import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } fro
 export declare class FloydWarshallAlgorithm extends DeclaredAlgorithm {
     static namespace: string;
     static type: string;
+    /** Measures every pair of the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * Measure the distance between every pair of nodes, and give each node the distance to the
      * node furthest from it.

package/dist/src/algorithms/GirvanNewmanAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import type { OptionsSchema } from "./types/OptionSchema";
 /**
@@ -18,6 +19,8 @@ interface GirvanNewmanOptions extends Record<string, unknown> {
 export declare class GirvanNewmanAlgorithm extends DeclaredAlgorithm<GirvanNewmanOptions> {
     static namespace: string;
     static type: string;
+    /** Groups over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/HITSAlgorithm.d.ts

@@ -1,5 +1,6 @@
 import type { FieldDescriptor, NodeId } from "../catalog/types";
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { MetricAlgorithm } from "./metrics/MetricAlgorithm";
 import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 import type { OptionsSchema } from "./types/OptionSchema";
@@ -29,6 +30,8 @@ interface HITSOptions extends Record<string, unknown> {
 export declare class HITSAlgorithm extends MetricAlgorithm<HITSOptions> {
     static namespace: string;
     static type: string;
+    /** Computes over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/KCoreAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import type { FieldDescriptor, NodeId } from "../catalog/types";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { MetricAlgorithm } from "./metrics/MetricAlgorithm";
 import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 /**
@@ -11,6 +12,8 @@ import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 export declare class KCoreAlgorithm extends MetricAlgorithm {
     static namespace: string;
     static type: string;
+    /** Computes over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * The fields a k-core result publishes.
      * @returns The uniform node-metric fields.

package/dist/src/algorithms/KatzCentralityAlgorithm.d.ts

@@ -1,5 +1,6 @@
 import type { FieldDescriptor, NodeId } from "../catalog/types";
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { MetricAlgorithm } from "./metrics/MetricAlgorithm";
 import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 import type { OptionsSchema } from "./types/OptionSchema";
@@ -31,6 +32,8 @@ interface KatzCentralityOptions extends Record<string, unknown> {
 export declare class KatzCentralityAlgorithm extends MetricAlgorithm<KatzCentralityOptions> {
     static namespace: string;
     static type: string;
+    /** Computes over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/KruskalAlgorithm.d.ts

@@ -5,13 +5,16 @@
  * algorithm. It returns an edge set: every edge says whether it is in the tree, and the run
  * publishes what the tree costs in total.
  */
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 /**
- *
+ * Kruskal's minimum spanning tree: the cheapest edges that join the graph, or the run's scope.
  */
 export declare class KruskalAlgorithm extends DeclaredAlgorithm {
     static namespace: string;
     static type: string;
+    /** Spans the run's scope: the edge list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * Find the cheapest set of edges that still joins every node.
      *

package/dist/src/algorithms/LabelPropagationAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import type { OptionsSchema } from "./types/OptionSchema";
 /**
@@ -16,6 +17,8 @@ interface LabelPropagationOptions extends Record<string, unknown> {
 export declare class LabelPropagationAlgorithm extends DeclaredAlgorithm<LabelPropagationOptions> {
     static namespace: string;
     static type: string;
+    /** Groups over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/LeidenAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import type { OptionsSchema } from "./types/OptionSchema";
 /**
@@ -20,6 +21,8 @@ interface LeidenOptions extends Record<string, unknown> {
 export declare class LeidenAlgorithm extends DeclaredAlgorithm<LeidenOptions> {
     static namespace: string;
     static type: string;
+    /** Groups over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/LinkPredictionAlgorithm.d.ts

@@ -8,6 +8,7 @@
  */
 import { adamicAdarPrediction, commonNeighborsPrediction } from "@graphty/algorithms";
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import type { OptionsSchema } from "./types/OptionSchema";
 /** The two scoring methods, by the name the `method` option takes. */
@@ -29,10 +30,12 @@ interface LinkPredictionOptions extends Record<string, unknown> {
 export declare class LinkPredictionAlgorithm extends DeclaredAlgorithm<LinkPredictionOptions> {
     static namespace: string;
     static type: string;
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**
-     * 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.
      */

package/dist/src/algorithms/LouvainAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import type { OptionsSchema } from "./types/OptionSchema";
 /**
@@ -20,6 +21,8 @@ interface LouvainOptions extends Record<string, unknown> {
 export declare class LouvainAlgorithm extends DeclaredAlgorithm<LouvainOptions> {
     static namespace: string;
     static type: string;
+    /** Groups over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/MaxFlowAlgorithm.d.ts

@@ -5,6 +5,7 @@
  * in a flow network using the Ford-Fulkerson method.
  */
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import { type OptionsSchema } from "./types/OptionSchema";
 /**
@@ -24,6 +25,8 @@ interface MaxFlowOptions extends Record<string, unknown> {
 export declare class MaxFlowAlgorithm extends DeclaredAlgorithm<MaxFlowOptions> {
     static namespace: string;
     static type: string;
+    /** Flows within the run's scope: the node and edge lists come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     /**
      * Options schema for Max Flow algorithm

package/dist/src/algorithms/MinCutAlgorithm.d.ts

@@ -5,6 +5,7 @@
  * or the global minimum cut of a graph. Uses the max-flow min-cut theorem.
  */
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import { type OptionsSchema } from "./types/OptionSchema";
 /**
@@ -31,6 +32,8 @@ interface MinCutOptions extends Record<string, unknown> {
 export declare class MinCutAlgorithm extends DeclaredAlgorithm<MinCutOptions> {
     static namespace: string;
     static type: string;
+    /** Cuts the run's scope: the node and edge lists and the graph all come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     /**
      * Options schema for Min Cut algorithm

package/dist/src/algorithms/PageRankAlgorithm.d.ts

@@ -3,6 +3,7 @@ import { z } from "zod/v4";
 import type { FieldDescriptor, NodeId } from "../catalog/types";
 import { type InferOptions } from "../config";
 import type { Graph } from "../Graph";
+import type { ScopeInputDeclaration } from "./input/ScopedInput";
 import { MetricAlgorithm } from "./metrics/MetricAlgorithm";
 import type { MetricMeasurement, MetricRunContext } from "./metrics/types";
 import type { OptionsSchema } from "./types/OptionSchema";
@@ -80,6 +81,8 @@ interface PageRankOptions extends PageRankSchemaOptions, Record<string, unknown>
 export declare class PageRankAlgorithm extends MetricAlgorithm<PageRankOptions> {
     static namespace: string;
     static type: string;
+    /** Ranks over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * NEW: Zod-based options schema for unified validation and UI metadata
      *

package/dist/src/algorithms/PrimAlgorithm.d.ts

@@ -9,6 +9,7 @@
  * from a starting node, which can be optionally configured.
  */
 import { type OptionsSchema as ZodOptionsSchema } from "../config";
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 import type { OptionsSchema } from "./types/OptionSchema";
 /**
@@ -27,6 +28,8 @@ interface PrimOptions extends Record<string, unknown> {
 export declare class PrimAlgorithm extends DeclaredAlgorithm<PrimOptions> {
     static namespace: string;
     static type: string;
+    /** Spans the run's scope: the edge list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     static zodOptionsSchema: ZodOptionsSchema;
     static optionsSchema: OptionsSchema;
     /**

package/dist/src/algorithms/StronglyConnectedComponentsAlgorithm.d.ts

@@ -1,3 +1,4 @@
+import { type ScopeInputDeclaration } from "./input/ScopedInput";
 import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } from "./results";
 /**
  *
@@ -5,6 +6,8 @@ import { type AlgorithmOutput, type AlgorithmRunContext, DeclaredAlgorithm } fro
 export declare class StronglyConnectedComponentsAlgorithm extends DeclaredAlgorithm {
     static namespace: string;
     static type: string;
+    /** Groups over the run's scope: the node list and the graph both come from the input. */
+    static scopeInput: ScopeInputDeclaration;
     /**
      * Find the pieces of the graph that a directed path can cross both ways.
      *