graphwise 1.12.0 → 1.12.1

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

@@ -1,36 +1,36 @@
 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 DOME expansion (degree-ordered).
+ * Run DOME exploration (degree-ordered).
  *
  * @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 dome<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function dome<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run DOME expansion asynchronously (degree-ordered).
+ * Run DOME exploration asynchronously (degree-ordered).
  *
  * @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 domeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function domeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 /**
  * DOME with reverse priority (high degree first).
  */
-export declare function domeHighDegree<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function domeHighDegree<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run DOME high-degree expansion asynchronously (high degree first).
+ * Run DOME high-degree exploration asynchronously (high degree first).
  *
  * @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 domeHighDegreeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function domeHighDegreeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=dome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dome.d.ts","sourceRoot":"","sources":["../../src/exploration/dome.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;AAsBnD;;;;;;;GAOG;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;;;;;;;GAOG;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,CAE5B;AAED;;GAEG;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,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC9B,iBAAiB,CAKnB;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,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,CAK5B"}

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

@@ -1,8 +1,8 @@
 /**
- * Integration test for DOME expansion algorithm.
+ * Integration test for DOME exploration algorithm.
  *
  * DOME demonstrates hub deferral: it defers exploration of high-degree nodes
- * and prioritises low-degree frontier expansion, discovering paths through
+ * and prioritises low-degree frontier exploration, discovering paths through
  * sparse regions before exhausting hub-centric neighbours.
  *
  * This test uses a social network with a hub (Alice, degree 10+) and niche

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

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

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

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

package/dist/{expansion → exploration}/edge.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 EDGE expansion (Entropy-Driven Graph Expansion).
+ * Run EDGE exploration (Entropy-Driven Graph Exploration).
  *
  * Discovers paths by prioritising nodes with diverse neighbour types,
  * deferring nodes with homogeneous neighbourhoods.
  *
  * @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 edge<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function edge<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run EDGE expansion asynchronously.
+ * Run EDGE exploration asynchronously.
  *
  * Delegates to `haeAsync` with the default `node.type` mapper.
  *
@@ -25,9 +25,9 @@ export declare function edge<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 edgeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function edgeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=edge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../src/exploration/edge.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,EAAE,IAAI,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAOnD;;;;;;;;;;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;;;;;;;;;;;;;;GAcG;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}/edge.integration.test.d.ts

@@ -1,5 +1,5 @@
 /**
- * Integration test for EDGE expansion algorithm.
+ * Integration test for EDGE exploration algorithm.
  *
  * EDGE discovers paths by prioritising nodes with diverse neighbour types.
  * High entropy (heterogeneous neighbourhoods) are expanded before low entropy

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

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

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

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

package/dist/{expansion → exploration}/flux.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';
 /**
- * Configuration for MAZE expansion.
+ * Configuration for MAZE exploration.
  */
-export interface MAZEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<N, E> {
+export interface MAZEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExplorationConfig<N, E> {
     /** Density threshold for switching to EDGE mode (default: 0.5) */
     readonly densityThreshold?: number;
     /** Bridge threshold for switching to PIPE mode (default: 0.3) */
     readonly bridgeThreshold?: number;
 }
 /**
- * Run FLUX expansion algorithm.
+ * Run FLUX exploration algorithm.
  *
- * Adaptively switches between expansion strategies based on
+ * Adaptively switches between exploration strategies based on
  * local graph structure. Useful for heterogeneous graphs
  * with varying density.
  *
  * @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 flux<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: MAZEConfig<N, E>): ExpansionResult;
+export declare function flux<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: MAZEConfig<N, E>): ExplorationResult;
 /**
- * Run FLUX expansion asynchronously.
+ * Run FLUX exploration asynchronously.
  *
  * Note: the FLUX priority function accesses `context.graph` to compute
  * local density and cross-frontier bridge scores. Full async equivalence
@@ -33,9 +33,9 @@ export declare function flux<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 - FLUX (MAZEConfig) configuration combined with async runner options
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function fluxAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: MAZEConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function fluxAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: MAZEConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=flux.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flux.d.ts","sourceRoot":"","sources":["../../src/exploration/flux.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;AAInD;;GAEG;AACH,MAAM,WAAW,UAAU,CAC1B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;IAChC,kEAAkE;IAClE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,iEAAiE;IACjE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CAClC;AA0ED;;;;;;;;;;;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,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,iBAAiB,CAcnB;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,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACpD,OAAO,CAAC,iBAAiB,CAAC,CAW5B"}

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

@@ -1,5 +1,5 @@
 /**
- * Integration test for FLUX expansion algorithm.
+ * Integration test for FLUX exploration algorithm.
  *
  * FLUX (Multi-phase Adaptive Zone Exploration) combines PIPE (phase 1),
  * SAGE (phase 2), and adaptive termination to discover paths across regions

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

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

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

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

package/dist/{expansion → exploration}/frontier-balanced.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 frontier-balanced expansion (round-robin across frontiers).
+ * Run frontier-balanced exploration (round-robin across frontiers).
  *
  * @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 frontierBalanced<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExpansionConfig<N, E>): ExpansionResult;
+export declare function frontierBalanced<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: ExplorationConfig<N, E>): ExplorationResult;
 /**
- * Run frontier-balanced expansion asynchronously (round-robin across frontiers).
+ * Run frontier-balanced exploration asynchronously (round-robin across frontiers).
  *
  * @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 frontierBalancedAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function frontierBalancedAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=frontier-balanced.d.ts.map

package/dist/exploration/frontier-balanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontier-balanced.d.ts","sourceRoot":"","sources":["../../src/exploration/frontier-balanced.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;AAanD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACtE,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,qBAAqB,CAC1C,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,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,CAE5B"}

package/dist/exploration/frontier-balanced.unit.test.d.ts.map

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

package/dist/{expansion → exploration}/fuse.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 FUSE expansion.
+ * Configuration for FUSE exploration.
  */
-export interface FUSEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<N, E> {
+export interface FUSEConfig<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;
     /** Weight for salience component (0-1, default: 0.5) */
@@ -16,19 +16,19 @@ export interface FUSEConfig<N extends NodeData = NodeData, E extends EdgeData =
  */
 export type SAGEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> = FUSEConfig<N, E>;
 /**
- * Run FUSE expansion algorithm.
+ * Run FUSE exploration algorithm.
  *
  * Combines structural exploration with semantic salience.
  * Useful for finding paths that are both short and semantically meaningful.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration with MI function
  * @returns Expansion result with discovered paths
  */
-export declare function fuse<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: FUSEConfig<N, E>): ExpansionResult;
+export declare function fuse<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: FUSEConfig<N, E>): ExplorationResult;
 /**
- * Run FUSE expansion asynchronously.
+ * Run FUSE exploration asynchronously.
  *
  * Note: the FUSE priority function accesses `context.graph` via
  * `avgFrontierMI`. Full async equivalence requires PriorityContext
@@ -36,11 +36,11 @@ export declare function fuse<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 - FUSE configuration combined with async runner options
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function fuseAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: FUSEConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function fuseAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: FUSEConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 /**
  * Create a batch priority function for FUSE with configurable weight.
  *

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

@@ -0,0 +1 @@
+{"version":3,"file":"fuse.d.ts","sourceRoot":"","sources":["../../src/exploration/fuse.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,UAAU,CAC1B,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,wDAAwD;IACxD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CACrB,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAC1B,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAwBrB;;;;;;;;;;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,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,iBAAiB,CAUnB;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,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACpD,OAAO,CAAC,iBAAiB,CAAC,CAO5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC7E,cAAc,SAAM,GAClB,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CA2B7B;AAED;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,qBACH,CAAC;AAE9B;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAE7B,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;IAAE,aAAa,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CAAE,CAKnE"}

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

@@ -1,5 +1,5 @@
 /**
- * Integration test for FUSE expansion algorithm.
+ * Integration test for FUSE exploration algorithm.
  *
  * FUSE (Salience-guided Adaptive Graph Expansion) is a two-phase algorithm
  * that accumulates salience feedback from discovered paths. Early high-MI paths

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

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

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

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

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

@@ -1,28 +1,28 @@
 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 HAE, extending base ExpansionConfig.
+ * Configuration for HAE, extending base ExplorationConfig.
  */
-export interface HAEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<N, E> {
+export interface HAEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExplorationConfig<N, E> {
     /** Function to extract type from a node (default: node.type) */
     readonly typeMapper?: (node: N) => string;
 }
 /**
- * Run HAE expansion (Heterogeneity-Aware Expansion).
+ * Run HAE exploration (Heterogeneity-Aware Exploration).
  *
  * Discovers paths by prioritising nodes with diverse neighbour types,
  * using a custom type mapper for flexible type extraction.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - HAE configuration with optional typeMapper
  * @returns Expansion result with discovered paths
  */
-export declare function hae<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: HAEConfig<N, E>): ExpansionResult;
+export declare function hae<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: HAEConfig<N, E>): ExplorationResult;
 /**
- * Run HAE expansion asynchronously.
+ * Run HAE exploration asynchronously.
  *
  * Note: the HAE priority function accesses `context.graph` to retrieve
  * neighbour types. Full async equivalence requires PriorityContext
@@ -30,9 +30,9 @@ export declare function hae<N extends NodeData, E extends EdgeData>(graph: Reada
  * 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 - HAE configuration combined with async runner options
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function haeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: HAEConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function haeAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: HAEConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 //# sourceMappingURL=hae.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hae.d.ts","sourceRoot":"","sources":["../../src/exploration/hae.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;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;AAMnD;;GAEG;AACH,MAAM,WAAW,SAAS,CACzB,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;IAChC,gEAAgE;IAChE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;CAC1C;AAuCD;;;;;;;;;;GAUG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACzD,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GACtB,iBAAiB,CAOnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,QAAQ,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACpE,KAAK,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACnD,OAAO,CAAC,iBAAiB,CAAC,CAO5B"}

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

@@ -1,7 +1,7 @@
 /**
- * Integration test for HAE expansion algorithm.
+ * Integration test for HAE exploration algorithm.
  *
- * HAE (Heterogeneity-Aware Expansion) generalises EDGE by allowing
+ * HAE (Heterogeneity-Aware Exploration) generalises EDGE by allowing
  * custom type extraction via a user-supplied typeMapper function.
  *
  * This test demonstrates HAE's ability to use custom type definitions

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

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

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

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

package/dist/exploration/index.cjs

@@ -0,0 +1,51 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_exploration = require("../exploration-BfDi17av.cjs");
+exports.base = require_exploration.base;
+exports.baseAsync = require_exploration.baseAsync;
+exports.createFuseBatchPriority = require_exploration.createFuseBatchPriority;
+exports.createSiftBatchPriority = require_exploration.createSiftBatchPriority;
+exports.dfsPriority = require_exploration.dfsPriority;
+exports.dfsPriorityAsync = require_exploration.dfsPriorityAsync;
+exports.dfsPriorityFn = require_exploration.dfsPriorityFn;
+exports.dome = require_exploration.dome;
+exports.domeAsync = require_exploration.domeAsync;
+exports.domeHighDegree = require_exploration.domeHighDegree;
+exports.domeHighDegreeAsync = require_exploration.domeHighDegreeAsync;
+exports.edge = require_exploration.edge;
+exports.edgeAsync = require_exploration.edgeAsync;
+exports.flux = require_exploration.flux;
+exports.fluxAsync = require_exploration.fluxAsync;
+exports.frontierBalanced = require_exploration.frontierBalanced;
+exports.frontierBalancedAsync = require_exploration.frontierBalancedAsync;
+exports.fuse = require_exploration.fuse;
+exports.fuseAsync = require_exploration.fuseAsync;
+exports.fuseBatchPriority = require_exploration.fuseBatchPriority;
+exports.fuseWithBatchPriority = require_exploration.fuseWithBatchPriority;
+exports.hae = require_exploration.hae;
+exports.haeAsync = require_exploration.haeAsync;
+exports.kHop = require_exploration.kHop;
+exports.lace = require_exploration.lace;
+exports.laceAsync = require_exploration.laceAsync;
+exports.laceBatchPriority = require_exploration.laceBatchPriority;
+exports.laceWithBatchPriority = require_exploration.laceWithBatchPriority;
+exports.maze = require_exploration.maze;
+exports.mazeAsync = require_exploration.mazeAsync;
+exports.pipe = require_exploration.pipe;
+exports.pipeAsync = require_exploration.pipeAsync;
+exports.randomPriority = require_exploration.randomPriority;
+exports.randomPriorityAsync = require_exploration.randomPriorityAsync;
+exports.randomWalk = require_exploration.randomWalk;
+exports.reach = require_exploration.reach;
+exports.reachAsync = require_exploration.reachAsync;
+exports.sage = require_exploration.sage;
+exports.sageAsync = require_exploration.sageAsync;
+exports.sift = require_exploration.sift;
+exports.siftAsync = require_exploration.siftAsync;
+exports.siftBatchPriority = require_exploration.siftBatchPriority;
+exports.siftWithBatchPriority = require_exploration.siftWithBatchPriority;
+exports.standardBfs = require_exploration.standardBfs;
+exports.standardBfsAsync = require_exploration.standardBfsAsync;
+exports.tide = require_exploration.tide;
+exports.tideAsync = require_exploration.tideAsync;
+exports.warp = require_exploration.warp;
+exports.warpAsync = require_exploration.warpAsync;

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

@@ -1,10 +1,10 @@
 /**
- * Expansion algorithms module.
+ * Exploration algorithms module.
  *
- * Provides bidirectional expansion algorithms for discovering paths
+ * Provides bidirectional exploration algorithms for discovering paths
  * between seed nodes in a graph.
  *
- * @module expansion
+ * @module exploration
  */
 export * from './types';
 export * from './base';

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/exploration/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC"}

package/dist/{expansion → exploration}/index.js

@@ -1,2 +1,2 @@
-import { A as tide, B as edge, C as fuseWithBatchPriority, D as laceAsync, E as lace, F as reachAsync, G as domeAsync, H as hae, I as sage, J as base, K as domeHighDegree, L as sageAsync, M as maze, N as mazeAsync, O as laceBatchPriority, P as reach, R as pipe, S as fuseBatchPriority, T as warpAsync, U as haeAsync, V as edgeAsync, W as dome, Y as baseAsync, _ as siftBatchPriority, a as dfsPriorityFn, b as fuse, c as frontierBalanced, d as standardBfsAsync, f as flux, g as siftAsync, h as sift, i as dfsPriorityAsync, j as tideAsync, k as laceWithBatchPriority, l as frontierBalancedAsync, m as createSiftBatchPriority, n as kHop, o as randomPriority, p as fluxAsync, q as domeHighDegreeAsync, r as dfsPriority, s as randomPriorityAsync, t as randomWalk, u as standardBfs, v as siftWithBatchPriority, w as warp, x as fuseAsync, y as createFuseBatchPriority, z as pipeAsync } from "../expansion-CZLNK6Pr.js";
+import { A as tide, B as edge, C as fuseWithBatchPriority, D as laceAsync, E as lace, F as reachAsync, G as domeAsync, H as hae, I as sage, J as base, K as domeHighDegree, L as sageAsync, M as maze, N as mazeAsync, O as laceBatchPriority, P as reach, R as pipe, S as fuseBatchPriority, T as warpAsync, U as haeAsync, V as edgeAsync, W as dome, Y as baseAsync, _ as siftBatchPriority, a as dfsPriorityFn, b as fuse, c as frontierBalanced, d as standardBfsAsync, f as flux, g as siftAsync, h as sift, i as dfsPriorityAsync, j as tideAsync, k as laceWithBatchPriority, l as frontierBalancedAsync, m as createSiftBatchPriority, n as kHop, o as randomPriority, p as fluxAsync, q as domeHighDegreeAsync, r as dfsPriority, s as randomPriorityAsync, t as randomWalk, u as standardBfs, v as siftWithBatchPriority, w as warp, x as fuseAsync, y as createFuseBatchPriority, z as pipeAsync } from "../exploration-DKjRNxS5.js";
 export { base, baseAsync, createFuseBatchPriority, createSiftBatchPriority, dfsPriority, dfsPriorityAsync, dfsPriorityFn, dome, domeAsync, domeHighDegree, domeHighDegreeAsync, edge, edgeAsync, flux, fluxAsync, frontierBalanced, frontierBalancedAsync, fuse, fuseAsync, fuseBatchPriority, fuseWithBatchPriority, hae, haeAsync, kHop, lace, laceAsync, laceBatchPriority, laceWithBatchPriority, maze, mazeAsync, pipe, pipeAsync, randomPriority, randomPriorityAsync, randomWalk, reach, reachAsync, sage, sageAsync, sift, siftAsync, siftBatchPriority, siftWithBatchPriority, standardBfs, standardBfsAsync, tide, tideAsync, warp, warpAsync };

package/dist/{expansion → exploration}/k-hop.d.ts

@@ -1,9 +1,9 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
-import { Seed, ExpansionResult, ExpansionConfig } from './types';
+import { Seed, ExplorationResult, ExplorationConfig } from './types';
 /**
- * Configuration for k-hop expansion.
+ * Configuration for k-hop exploration.
  */
-export interface KHopConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<N, E> {
+export interface KHopConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExplorationConfig<N, E> {
     /**
      * Maximum number of hops from any seed node.
      * Defaults to 2.
@@ -11,16 +11,16 @@ export interface KHopConfig<N extends NodeData = NodeData, E extends EdgeData =
     readonly k?: number;
 }
 /**
- * Run k-hop expansion (fixed-depth BFS).
+ * Run k-hop exploration (fixed-depth BFS).
  *
  * Explores all nodes reachable within exactly k hops of any seed using
  * breadth-first search. Paths between seeds are detected when a node
  * is reached by frontiers from two different seeds.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - K-hop configuration (k defaults to 2)
  * @returns Expansion result with discovered paths
  */
-export declare function kHop<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: KHopConfig<N, E>): ExpansionResult;
+export declare function kHop<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: KHopConfig<N, E>): ExplorationResult;
 //# sourceMappingURL=k-hop.d.ts.map

package/dist/exploration/k-hop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k-hop.d.ts","sourceRoot":"","sources":["../../src/exploration/k-hop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAU,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EAGjB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,UAAU,CAC1B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;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,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,iBAAiB,CA4JnB"}

package/dist/exploration/k-hop.unit.test.d.ts.map

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

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

@@ -1,28 +1,28 @@
 import { NodeData, EdgeData, ReadableGraph, NodeId } from '../graph';
 import { AsyncReadableGraph } from '../graph/async-interfaces';
-import { Seed, ExpansionResult, ExpansionConfig, BatchPriorityContext, BatchPriorityFunction } from './types';
+import { Seed, ExplorationResult, ExplorationConfig, BatchPriorityContext, BatchPriorityFunction } from './types';
 import { AsyncExpansionConfig } from './base';
 /**
- * Configuration for LACE expansion.
+ * Configuration for LACE exploration.
  */
-export interface LACEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<N, E> {
+export interface LACEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExplorationConfig<N, E> {
     /** MI function for computing edge priorities (default: jaccard) */
     readonly mi?: (graph: ReadableGraph<N, E>, source: string, target: string) => number;
 }
 /**
- * Run LACE expansion algorithm.
+ * Run LACE exploration algorithm.
  *
  * Expands from seeds prioritising high-MI edges.
  * Useful for finding paths with strong semantic associations.
  *
  * @param graph - Source graph
- * @param seeds - Seed nodes for expansion
+ * @param seeds - Seed nodes for exploration
  * @param config - Expansion configuration with MI function
  * @returns Expansion result with discovered paths
  */
-export declare function lace<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: LACEConfig<N, E>): ExpansionResult;
+export declare function lace<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, seeds: readonly Seed[], config?: LACEConfig<N, E>): ExplorationResult;
 /**
- * Run LACE expansion asynchronously.
+ * Run LACE exploration asynchronously.
  *
  * Note: the LACE priority function accesses `context.graph` via
  * `avgFrontierMI`. Full async equivalence requires PriorityContext
@@ -30,13 +30,13 @@ export declare function lace<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 - LACE configuration combined with async runner options
- * @returns Promise resolving to the expansion result
+ * @returns Promise resolving to the exploration result
  */
-export declare function laceAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: LACEConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExpansionResult>;
+export declare function laceAsync<N extends NodeData, E extends EdgeData>(graph: AsyncReadableGraph<N, E>, seeds: readonly Seed[], config?: LACEConfig<N, E> & AsyncExpansionConfig<N, E>): Promise<ExplorationResult>;
 /**
- * Batch priority function for LACE expansion.
+ * Batch priority function for LACE exploration.
  *
  * Computes average MI between each candidate and all nodes visited by the
  * same frontier in a single batch operation. More efficient than computing

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

@@ -0,0 +1 @@
+{"version":3,"file":"lace.d.ts","sourceRoot":"","sources":["../../src/exploration/lace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACX,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EAEjB,oBAAoB,EACpB,qBAAqB,EACrB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AASnD;;GAEG;AACH,MAAM,WAAW,UAAU,CAC1B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;IAChC,mEAAmE;IACnE,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;CACZ;AAkBD;;;;;;;;;;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,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,iBAAiB,CAUnB;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,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACpD,OAAO,CAAC,iBAAiB,CAAC,CAO5B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EACvE,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAmB7B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAE7B,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG;IAAE,aAAa,EAAE,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;CAAE,CAKnE"}

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

@@ -1,5 +1,5 @@
 /**
- * Integration test for LACE expansion algorithm.
+ * Integration test for LACE exploration algorithm.
  *
  * LACE (Local Adaptive Community Entropy) is a single-phase algorithm that uses
  * a user-supplied entropy function for node prioritisation. Unlike TIDE

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

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

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

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