graphwise 1.12.0 → 1.12.1

package/dist/{expansion → exploration}/maze.d.ts

@@ -1,21 +1,21 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig } from './types';
+import { Seed, ExplorationResult, ExplorationConfig } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Run MAZE expansion algorithm.
+ * Run MAZE exploration algorithm.
  *
- * Multi-phase expansion combining path potential and salience with
+ * Multi-phase exploration combining path potential and salience with
  * adaptive frontier steering.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration
  * @returns Expansion result with discovered paths
  */
-export declare function maze<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function maze<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run MAZE expansion asynchronously.
+ * Run MAZE exploration asynchronously.
  *
  * Creates fresh closure state (salienceCounts, phase tracking) for this
  * invocation. The MAZE priority function accesses `context.graph` to
@@ -24,9 +24,9 @@ export declare function maze<N extends NodeData, E extends EdgeData>(graph: Read
  * This export establishes the async API surface.
  *
  * @param graph - Async source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion and async runner configuration
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function mazeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function mazeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=maze.d.ts.map

package/dist/exploration/maze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maze.d.ts","sourceRoot":"","sources":["../../src/exploration/maze.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAU,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAEjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAUnD;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC9B,iBAAiB,CA8DnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACrE,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,CAgD5B"}

package/dist/{expansion → exploration}/maze.integration.test.d.ts

@@ -1,5 +1,5 @@
 /**
- * Integration test for MAZE expansion algorithm.
+ * Integration test for MAZE exploration algorithm.
  *
  * MAZE demonstrates combined path potential (PIPE) and salience feedback
  * with multi-phase adaptive exploration.

package/dist/exploration/maze.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maze.integration.test.d.ts","sourceRoot":"","sources":["../../src/exploration/maze.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/exploration/maze.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maze.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/maze.unit.test.ts"],"names":[],"mappings":""}

package/dist/{expansion → exploration}/pipe.d.ts

@@ -1,21 +1,21 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig } from './types';
+import { Seed, ExplorationResult, ExplorationConfig } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Run PIPE expansion (Path-Potential Informed Priority Expansion).
+ * Run PIPE exploration (Path-potential Informed Priority Exploration).
  *
  * Discovers paths by prioritising nodes that bridge multiple frontiers,
  * identifying connecting points between seed regions.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration
  * @returns Expansion result with discovered paths
  */
-export declare function pipe<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function pipe<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run PIPE expansion asynchronously.
+ * Run PIPE exploration asynchronously.
  *
  * Note: the PIPE priority function accesses `context.graph` to retrieve
  * neighbour lists. Full async equivalence requires PriorityContext
@@ -23,9 +23,9 @@ export declare function pipe<N extends NodeData, E extends EdgeData>(graph: Read
  * surface; use with a `wrapAsync`-wrapped sync graph for testing.
  *
  * @param graph - Async source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion and async runner configuration
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function pipeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function pipeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=pipe.d.ts.map

package/dist/exploration/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../../src/exploration/pipe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAEjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AA+BnD;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC9B,iBAAiB,CAKnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACrE,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,CAK5B"}

package/dist/{expansion → exploration}/pipe.integration.test.d.ts

@@ -1,7 +1,7 @@
 /**
- * Integration test for PIPE expansion algorithm.
+ * Integration test for PIPE exploration algorithm.
  *
- * PIPE (Path-Potential Informed Priority Expansion) prioritises nodes
+ * PIPE (Path-potential Informed Priority Exploration) prioritises nodes
  * that bridge multiple frontiers, discovering paths by focusing on
  * connection points between seed regions.
  *

package/dist/exploration/pipe.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.integration.test.d.ts","sourceRoot":"","sources":["../../src/exploration/pipe.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/exploration/pipe.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/pipe.unit.test.ts"],"names":[],"mappings":""}

package/dist/{expansion → exploration}/priority-helpers.d.ts

@@ -1,5 +1,5 @@
 import { NodeId, NodeData, EdgeData, ReadableGraph } from '../graph';
-import { PriorityContext, ExpansionPath, BatchPriorityContext } from './types';
+import { PriorityContext, ExplorationPath, BatchPriorityContext } from './types';
 /**
  * Compute average MI between each candidate and a set of reference nodes.
  *
@@ -58,5 +58,5 @@ export declare function countCrossFrontierNeighbours<N extends NodeData, E exten
  * @param fromIndex - Index to start counting from (exclusive of earlier paths)
  * @returns The new `fromIndex` value (i.e. `paths.length` after update)
  */
-export declare function updateSalienceCounts(salienceCounts: Map<NodeId, number>, paths: readonly ExpansionPath[], fromIndex: number): number;
+export declare function updateSalienceCounts(salienceCounts: Map<NodeId, number>, paths: readonly ExplorationPath[], fromIndex: number): number;
 //# sourceMappingURL=priority-helpers.d.ts.map

package/dist/exploration/priority-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-helpers.d.ts","sourceRoot":"","sources":["../../src/exploration/priority-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EACX,eAAe,EACf,eAAe,EACf,oBAAoB,EACpB,MAAM,SAAS,CAAC;AAQjB;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAChE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,GACjC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CA6F7B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACnE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,EAAE,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,GACxE,MAAM,CAcR;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC5E,OAAO,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,GAAG,CAAC,MAAM,CAAC,CAQb;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAC3C,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,QAAQ,EAElB,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,MAAM,CAYR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CACnC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACnC,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,SAAS,EAAE,MAAM,GACf,MAAM,CAUR"}

package/dist/{expansion → exploration}/random-priority.d.ts

@@ -1,38 +1,38 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig } from './types';
+import { Seed, ExplorationResult, ExplorationConfig } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Configuration for random-priority expansion.
+ * Configuration for random-priority exploration.
  */
-interface RandomPriorityConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<N, E> {
+interface RandomPriorityConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExplorationConfig<N, E> {
     /** Random seed for deterministic reproducibility */
     readonly seed?: number;
 }
 /**
- * Async configuration for random-priority expansion.
+ * Async configuration for random-priority exploration.
  */
 interface AsyncRandomPriorityConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends AsyncExpansionConfig<N, E> {
     /** Random seed for deterministic reproducibility */
     readonly seed?: number;
 }
 /**
- * Run random-priority expansion (null hypothesis baseline).
+ * Run random-priority exploration (null hypothesis baseline).
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration
  * @returns Expansion result with discovered paths
  */
-export declare function randomPriority<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: RandomPriorityConfig<N, E>): ExpansionResult;
+export declare function randomPriority<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: RandomPriorityConfig<N, E>): ExplorationResult;
 /**
- * Run random-priority expansion asynchronously (null hypothesis baseline).
+ * Run random-priority exploration asynchronously (null hypothesis baseline).
  *
  * @param graph - Async source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion and async runner configuration
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function randomPriorityAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncRandomPriorityConfig<N, E>): Promise<ExpansionResult>;
+export declare function randomPriorityAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncRandomPriorityConfig<N, E>): Promise<ExplorationResult>;
 export {};
 //# sourceMappingURL=random-priority.d.ts.map

package/dist/exploration/random-priority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-priority.d.ts","sourceRoot":"","sources":["../../src/exploration/random-priority.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAEjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAqBnD;;GAEG;AACH,UAAU,oBAAoB,CAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;IAChC,oDAAoD;IACpD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,UAAU,yBAAyB,CAClC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC;IACnC,oDAAoD;IACpD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACvB;AAWD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACpE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,iBAAiB,CAMnB;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACxC,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,QAAQ,EAElB,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC,GACtC,OAAO,CAAC,iBAAiB,CAAC,CAM5B"}

package/dist/exploration/random-priority.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-priority.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/random-priority.unit.test.ts"],"names":[],"mappings":""}

package/dist/{expansion → exploration}/random-walk.d.ts

@@ -1,7 +1,7 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
-import { Seed, ExpansionResult } from './types';
+import { Seed, ExplorationResult } from './types';
 /**
- * Configuration for random-walk-with-restart expansion.
+ * Configuration for random-walk-with-restart exploration.
  */
 export interface RandomWalkConfig {
     /** Probability of restarting a walk from its seed node (default: 0.15). */
@@ -14,7 +14,7 @@ export interface RandomWalkConfig {
     readonly seed?: number;
 }
 /**
- * Run random-walk-with-restart expansion.
+ * Run random-walk-with-restart exploration.
  *
  * For each seed, performs `walks` independent random walks of up to
  * `walkLength` steps. At each step the walk either restarts (with
@@ -24,12 +24,12 @@ export interface RandomWalkConfig {
  * Inter-seed paths are detected when a walk reaches a node that was
  * previously reached by a walk originating from a different seed.
  * The recorded path contains only the two seed endpoints rather than
- * the full walk trajectory, consistent with the ExpansionPath contract.
+ * the full walk trajectory, consistent with the ExplorationPath contract.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Random walk configuration
  * @returns Expansion result with discovered paths
  */
-export declare function randomWalk<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: RandomWalkConfig): ExpansionResult;
+export declare function randomWalk<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: RandomWalkConfig): ExplorationResult;
 //# sourceMappingURL=random-walk.d.ts.map

package/dist/exploration/random-walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-walk.d.ts","sourceRoot":"","sources":["../../src/exploration/random-walk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAU,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EAGjB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,2EAA2E;IAC3E,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACvB;AAqBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAChE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,gBAAgB,GACvB,iBAAiB,CAwJnB"}

package/dist/exploration/random-walk.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-walk.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/random-walk.unit.test.ts"],"names":[],"mappings":""}

package/dist/{expansion → exploration}/reach.d.ts

@@ -1,22 +1,22 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig } from './types';
+import { Seed, ExplorationResult, ExplorationConfig } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Run REACH expansion algorithm.
+ * Run REACH exploration algorithm.
  *
- * Mutual information-aware multi-frontier expansion with two phases:
+ * Mutual information-aware multi-frontier exploration with two phases:
  * - Phase 1: Degree-based priority (early exploration)
  * - Phase 2: Structural similarity feedback (MI-guided frontier steering)
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration
  * @returns Expansion result with discovered paths
  */
-export declare function reach<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function reach<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run REACH expansion asynchronously.
+ * Run REACH exploration asynchronously.
  *
  * Creates fresh closure state (phase tracking, Jaccard cache) for this
  * invocation. The REACH priority function uses `jaccard(context.graph, ...)`
@@ -25,9 +25,9 @@ export declare function reach<N extends NodeData, E extends EdgeData>(graph: Rea
  * deferred). This export establishes the async API surface.
  *
  * @param graph - Async source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion and async runner configuration
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function reachAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function reachAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=reach.d.ts.map

package/dist/exploration/reach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reach.d.ts","sourceRoot":"","sources":["../../src/exploration/reach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAU,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAEjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAInD;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC3D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC9B,iBAAiB,CA2EnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACtE,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,CAmC5B"}

package/dist/{expansion → exploration}/reach.integration.test.d.ts

@@ -1,5 +1,5 @@
 /**
- * Integration test for REACH expansion algorithm.
+ * Integration test for REACH exploration algorithm.
  *
  * REACH demonstrates MI-based hub deferral: it computes mean Jaccard
  * similarity between candidate nodes and discovered path endpoints,

package/dist/exploration/reach.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reach.integration.test.d.ts","sourceRoot":"","sources":["../../src/exploration/reach.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/exploration/reach.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reach.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/reach.unit.test.ts"],"names":[],"mappings":""}

package/dist/{expansion → exploration}/sage.d.ts

@@ -1,31 +1,31 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig } from './types';
+import { Seed, ExplorationResult, ExplorationConfig } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Run SAGE expansion algorithm.
+ * Run SAGE exploration algorithm.
  *
- * Salience-aware multi-frontier expansion with two phases:
+ * Salience-aware multi-frontier exploration with two phases:
  * - Phase 1: Degree-based priority (early exploration)
  * - Phase 2: Salience feedback (path-aware frontier steering)
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration
  * @returns Expansion result with discovered paths
  */
-export declare function sage<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function sage<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run SAGE expansion asynchronously.
+ * Run SAGE exploration asynchronously.
  *
  * Creates fresh closure state (salienceCounts, phase tracking) for this
  * invocation. The SAGE priority function does not access `context.graph`
  * directly, so it is safe to use in async mode via `baseAsync`.
  *
  * @param graph - Async source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion and async runner configuration
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function sageAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function sageAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=sage.d.ts.map

package/dist/exploration/sage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sage.d.ts","sourceRoot":"","sources":["../../src/exploration/sage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAU,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAEjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAInD;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC9B,iBAAiB,CA6CnB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACrE,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,CAiC5B"}

package/dist/{expansion → exploration}/sage.integration.test.d.ts

@@ -1,5 +1,5 @@
 /**
- * Integration test for SAGE expansion algorithm.
+ * Integration test for SAGE exploration algorithm.
  *
  * SAGE demonstrates salience-based hub deferral: it deprioritises nodes
  * that appear frequently in discovered paths, encouraging exploration

package/dist/exploration/sage.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sage.integration.test.d.ts","sourceRoot":"","sources":["../../src/exploration/sage.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/exploration/sage.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sage.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/sage.unit.test.ts"],"names":[],"mappings":""}

package/dist/{expansion → exploration}/sift.d.ts

@@ -1,11 +1,11 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig, BatchPriorityFunction } from './types';
+import { Seed, ExplorationResult, ExplorationConfig, BatchPriorityFunction } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Configuration for REACH expansion.
+ * Configuration for REACH exploration.
  */
-export interface REACHConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<N, E> {
+export interface REACHConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExplorationConfig<N, E> {
     /** MI function for salience computation (default: jaccard) */
     readonly mi?: (graph: ReadableGraph<N, E>, source: string, target: string) => number;
     /** MI percentile threshold for phase 2 (default: 0.25) */
@@ -14,19 +14,19 @@ export interface REACHConfig<N extends NodeData = NodeData, E extends EdgeData =
     readonly phase1MaxNodes?: number;
 }
 /**
- * Run SIFT expansion algorithm.
+ * Run SIFT exploration algorithm.
  *
- * Two-phase adaptive expansion that learns MI thresholds
- * from initial sampling, then uses them for guided expansion.
+ * Two-phase adaptive exploration that learns MI thresholds
+ * from initial sampling, then uses them for guided exploration.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration
  * @returns Expansion result with discovered paths
  */
-export declare function sift<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: REACHConfig<N, E>): ExpansionResult;
+export declare function sift<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: REACHConfig<N, E>): ExplorationResult;
 /**
- * Run SIFT expansion asynchronously.
+ * Run SIFT exploration asynchronously.
  *
  * Note: the SIFT priority function accesses `context.graph` via
  * `avgFrontierMI`. Full async equivalence requires PriorityContext
@@ -34,11 +34,11 @@ export declare function sift<N extends NodeData, E extends EdgeData>(graph: Read
  * API surface.
  *
  * @param graph - Async source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - SIFT (REACHConfig) configuration combined with async runner options
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function siftAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: REACHConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function siftAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: REACHConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 /**
  * Create a batch priority function for SIFT with configurable threshold.
  *

package/dist/exploration/sift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sift.d.ts","sourceRoot":"","sources":["../../src/exploration/sift.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAU,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAGjB,qBAAqB,EACrB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AASnD;;GAEG;AACH,MAAM,WAAW,WAAW,CAC3B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,CAAC,EAAE,CACb,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,KACV,MAAM,CAAC;IACZ,0DAA0D;IAC1D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACjC;AAyBD;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACxB,iBAAiB,CAWnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACrE,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACrD,OAAO,CAAC,iBAAiB,CAAC,CAO5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC7E,WAAW,SAAO,GAChB,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CA+B7B;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,qBACF,CAAC;AAE/B;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAE7B,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GACxB,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;IAAE,aAAa,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CAAE,CAKpE"}

package/dist/{expansion → exploration}/sift.integration.test.d.ts

@@ -1,5 +1,5 @@
 /**
- * Integration test for SIFT expansion algorithm.
+ * Integration test for SIFT exploration algorithm.
  *
  * SIFT (Rolling Estimated Adaptive Community Heuristic) is a two-phase algorithm
  * that adapts the MI threshold during phase 2. It uses rolling MI estimates of

package/dist/exploration/sift.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sift.integration.test.d.ts","sourceRoot":"","sources":["../../src/exploration/sift.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/exploration/sift.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sift.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/sift.unit.test.ts"],"names":[],"mappings":""}

package/dist/{expansion → exploration}/standard-bfs.d.ts

@@ -1,23 +1,23 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig } from './types';
+import { Seed, ExplorationResult, ExplorationConfig } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Run standard BFS expansion (FIFO discovery order).
+ * Run standard BFS exploration (FIFO discovery order).
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration
  * @returns Expansion result with discovered paths
  */
-export declare function standardBfs<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function standardBfs<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run standard BFS expansion asynchronously (FIFO discovery order).
+ * Run standard BFS exploration asynchronously (FIFO discovery order).
  *
  * @param graph - Async source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion and async runner configuration
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function standardBfsAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function standardBfsAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=standard-bfs.d.ts.map

package/dist/exploration/standard-bfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-bfs.d.ts","sourceRoot":"","sources":["../../src/exploration/standard-bfs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAEjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAYnD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACjE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC9B,iBAAiB,CAKnB;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC5E,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,CAE5B"}

package/dist/exploration/standard-bfs.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-bfs.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/standard-bfs.unit.test.ts"],"names":[],"mappings":""}

package/dist/{expansion → exploration}/tide.d.ts

@@ -1,21 +1,21 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig } from './types';
+import { Seed, ExplorationResult, ExplorationConfig } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Run TIDE expansion algorithm.
+ * Run TIDE exploration algorithm.
  *
  * Expands from seeds prioritising low-degree edges first.
  * Useful for avoiding hubs and exploring sparse regions.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration
  * @returns Expansion result with discovered paths
  */
-export declare function tide<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function tide<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run TIDE expansion asynchronously.
+ * Run TIDE exploration asynchronously.
  *
  * Note: the TIDE priority function accesses `context.graph` to retrieve
  * neighbour lists and per-neighbour degrees. Full async equivalence
@@ -23,9 +23,9 @@ export declare function tide<N extends NodeData, E extends EdgeData>(graph: Read
  * establishes the async API surface.
  *
  * @param graph - Async source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion and async runner configuration
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function tideAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function tideAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=tide.d.ts.map

package/dist/exploration/tide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tide.d.ts","sourceRoot":"","sources":["../../src/exploration/tide.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAEjB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAwBnD;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC1D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC9B,iBAAiB,CAKnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACrE,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,CAK5B"}

package/dist/{expansion → exploration}/tide.integration.test.d.ts

@@ -1,5 +1,5 @@
 /**
- * Integration test for TIDE expansion algorithm.
+ * Integration test for TIDE exploration algorithm.
  *
  * TIDE (Type-Integrated Degree Estimation) targets sparse regions by using
  * neighbourhood entropy as a priority heuristic. It explores through areas

package/dist/exploration/tide.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tide.integration.test.d.ts","sourceRoot":"","sources":["../../src/exploration/tide.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/exploration/tide.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tide.unit.test.d.ts","sourceRoot":"","sources":["../../src/exploration/tide.unit.test.ts"],"names":[],"mappings":""}