graphwise 1.3.2 → 1.4.0

package/README.md

@@ -1,5 +1,6 @@
 # graphwise
 
+[![DOI](https://zenodo.org/badge/1190809040.svg)](https://doi.org/10.5281/zenodo.19209820)
 [![npm](https://img.shields.io/badge/npm-cb3837?logo=npm)](https://www.npmjs.com/package/graphwise)
 [![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github)](https://github.com/Mearman/graphwise)
 
@@ -7,7 +8,7 @@ Low-dependency TypeScript graph algorithms for citation network analysis: novel
 
 ## Features
 
-- **Expansion algorithms**: BASE, DOME, EDGE, HAE, PIPE, SAGE, REACH, MAZE + baselines
+- **Expansion algorithms**: BASE, DOME, EDGE, HAE, PIPE, SAGE, REACH, MAZE + 6 variants (TIDE, LACE, WARP, FUSE, SIFT, FLUX) + baselines
 - **MI variants**: Jaccard, Adamic-Adar, SCALE, SKEW, SPAN, ETCH, NOTCH, Unified Adaptive
 - **Path ranking**: PARSE + baselines (Katz, Communicability, PageRank, etc.)
 - **Seed selection**: GRASP, Stratified
@@ -65,6 +66,76 @@ where $\deg^{+}(v)$ is weighted out-degree, $\deg^{-}(v)$ is weighted in-degree,
 | **SAGE**  | Salience accumulation from discovered paths            | 2      |
 | **REACH** | Rolling MI estimates of discovered path quality        | 2      |
 | **MAZE**  | PIPE + SAGE + adaptive termination                     | 3      |
+| **TIDE**  | Sum of node + all-neighbour degrees                    | 1      |
+| **LACE**  | Average MI to same-frontier visited nodes              | 1      |
+| **WARP**  | Cross-frontier bridge score                            | 1      |
+| **FUSE**  | Weighted degree + MI blend                             | 1      |
+| **SIFT**  | MI threshold with degree fallback                      | 1      |
+| **FLUX**  | Density-adaptive strategy switching                    | 1      |
+
+#### EDGE: Entropy-Driven Graph Expansion
+
+$$\pi_{\text{EDGE}}(v) = \frac{1}{H_{\text{local}}(v) + \varepsilon} \times \log(\deg(v) + 1)$$
+
+where $H_{\text{local}}(v) = -\sum_{\tau} p(\tau) \log p(\tau)$ is the Shannon entropy of the neighbour type distribution. Nodes bridging heterogeneous structural regimes (high entropy) are explored first.
+
+#### PIPE: Path-potential Informed Priority Expansion
+
+$$\pi_{\text{PIPE}}(v) = \frac{\deg(v)}{1 + \text{path\_potential}(v)}$$
+
+where $\text{path\_potential}(v) = |N(v) \cap \bigcup_{j \neq i} V_j|$ counts neighbours already visited by other seed frontiers. High path potential indicates imminent path completion.
+
+#### SAGE: Salience-Accumulation Guided Expansion
+
+$$\pi_{\text{SAGE}}(v) = \begin{cases} \log(\deg(v) + 1) & \text{Phase 1 (before first path)} \\ -(\text{salience}(v) \times 1000 - \deg(v)) & \text{Phase 2 (after first path)} \end{cases}$$
+
+where $\text{salience}(v)$ counts discovered paths containing $v$. Salience dominates in Phase 2; degree serves as tiebreaker.
+
+#### REACH: Retrospective Expansion with Adaptive Convergence
+
+$$\pi_{\text{REACH}}(v) = \begin{cases} \log(\deg(v) + 1) & \text{Phase 1} \\ \log(\deg(v) + 1) \times (1 - \widehat{\text{MI}}(v)) & \text{Phase 2} \end{cases}$$
+
+where $\widehat{\text{MI}}(v) = \frac{1}{|\mathcal{P}_{\text{top}}|} \sum_{p} J(N(v), N(p_{\text{endpoint}}))$ estimates MI via Jaccard similarity to discovered path endpoints.
+
+#### MAZE: Multi-frontier Adaptive Zone Expansion
+
+$$\pi^{(1)}(v) = \frac{\deg(v)}{1 + \text{path\_potential}(v)} \qquad \pi^{(2)}(v) = \pi^{(1)}(v) \times \frac{1}{1 + \lambda \cdot \text{salience}(v)}$$
+
+Phase 1 uses PIPE's path potential until $M$ paths found. Phase 2 incorporates SAGE's salience feedback. Phase 3 evaluates diversity, path count, and salience plateau for termination.
+
+#### TIDE: Total Interconnected Degree Expansion
+
+$$\pi_{\text{TIDE}}(v) = \deg(v) + \sum_{w \in N(v)} \deg(w)$$
+
+Nodes in sparse regions (low aggregate neighbourhood degree) are explored first. Related to EDGE but uses raw degree sums rather than entropy.
+
+#### LACE: Local Affinity-Computed Expansion
+
+$$\pi_{\text{LACE}}(v) = 1 - \overline{\text{MI}}(v, \text{frontier})$$
+
+Prioritises nodes by average MI to already-visited frontier nodes. Related to HAE but uses MI to visited nodes rather than type entropy.
+
+#### WARP: Weighted Adjacent Reachability Priority
+
+$$\pi_{\text{WARP}}(v) = \frac{1}{1 + \text{bridge}(v)}$$
+
+Pure cross-frontier bridge score without degree normalisation. Related to PIPE but omits the degree numerator.
+
+#### FUSE: Fused Utility-Salience Expansion
+
+$$\pi_{\text{FUSE}}(v) = (1 - w) \cdot \deg(v) + w \cdot (1 - \overline{\text{MI}})$$
+
+Single-phase weighted blend of degree and MI. Related to SAGE but uses continuous blending rather than two-phase transition.
+
+#### SIFT: Salience-Informed Frontier Threshold
+
+$$\pi_{\text{SIFT}}(v) = \begin{cases} 1 - \overline{\text{MI}} & \text{if } \overline{\text{MI}} \geq \tau \\ \deg(v) + 100 & \text{otherwise} \end{cases}$$
+
+MI-threshold-based priority with degree fallback. Related to REACH but uses a hard threshold instead of continuous MI-weighted priority.
+
+#### FLUX: Flexible Local Utility Crossover
+
+Density-adaptive strategy switching. Selects between DOME, EDGE, and PIPE modes per-node based on local graph density and cross-frontier bridge score. Related to MAZE but adapts spatially (per-node) rather than temporally (per-phase).
 
 ### Path Ranking: PARSE
 

package/dist/__test__/fixtures/graphs/city-suburban-village.d.ts

@@ -0,0 +1,3 @@
+import { TestGraphFixture } from '../types';
+export declare function createCitySuburbanVillageFixture(): TestGraphFixture;
+//# sourceMappingURL=city-suburban-village.d.ts.map

package/dist/__test__/fixtures/graphs/city-suburban-village.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"city-suburban-village.d.ts","sourceRoot":"","sources":["../../../../src/__test__/fixtures/graphs/city-suburban-village.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,wBAAgB,gCAAgC,IAAI,gBAAgB,CA6HnE"}

package/dist/__test__/fixtures/graphs/city-village.d.ts

@@ -0,0 +1,3 @@
+import { TestGraphFixture } from '../types';
+export declare function createCityVillageFixture(): TestGraphFixture;
+//# sourceMappingURL=city-village.d.ts.map

package/dist/__test__/fixtures/graphs/city-village.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"city-village.d.ts","sourceRoot":"","sources":["../../../../src/__test__/fixtures/graphs/city-village.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,wBAAgB,wBAAwB,IAAI,gBAAgB,CAmF3D"}

package/dist/__test__/fixtures/graphs/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Test graph fixture builders.
+ *
+ * Each builder creates a complete test graph with nodes, edges, seeds, and metadata.
+ */
+export * from './social-hub';
+export * from './two-department';
+export * from './city-village';
+export * from './city-suburban-village';
+export * from './typed-entity';
+export * from './three-community';
+export * from './quality-vs-popularity';
+//# sourceMappingURL=index.d.ts.map

package/dist/__test__/fixtures/graphs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/__test__/fixtures/graphs/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC"}

package/dist/__test__/fixtures/graphs/quality-vs-popularity.d.ts

@@ -0,0 +1,3 @@
+import { TestGraphFixture } from '../types';
+export declare function createQualityVsPopularityFixture(): TestGraphFixture;
+//# sourceMappingURL=quality-vs-popularity.d.ts.map

package/dist/__test__/fixtures/graphs/quality-vs-popularity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-vs-popularity.d.ts","sourceRoot":"","sources":["../../../../src/__test__/fixtures/graphs/quality-vs-popularity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,wBAAgB,gCAAgC,IAAI,gBAAgB,CAgLnE"}

package/dist/__test__/fixtures/graphs/social-hub.d.ts

@@ -0,0 +1,3 @@
+import { TestGraphFixture } from '../types';
+export declare function createSocialHubFixture(): TestGraphFixture;
+//# sourceMappingURL=social-hub.d.ts.map

package/dist/__test__/fixtures/graphs/social-hub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"social-hub.d.ts","sourceRoot":"","sources":["../../../../src/__test__/fixtures/graphs/social-hub.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,wBAAgB,sBAAsB,IAAI,gBAAgB,CAuFzD"}

package/dist/__test__/fixtures/graphs/three-community.d.ts

@@ -0,0 +1,3 @@
+import { TestGraphFixture } from '../types';
+export declare function createThreeCommunityFixture(): TestGraphFixture;
+//# sourceMappingURL=three-community.d.ts.map

package/dist/__test__/fixtures/graphs/three-community.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"three-community.d.ts","sourceRoot":"","sources":["../../../../src/__test__/fixtures/graphs/three-community.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,wBAAgB,2BAA2B,IAAI,gBAAgB,CAqK9D"}

package/dist/__test__/fixtures/graphs/two-department.d.ts

@@ -0,0 +1,3 @@
+import { TestGraphFixture } from '../types';
+export declare function createTwoDepartmentFixture(): TestGraphFixture;
+//# sourceMappingURL=two-department.d.ts.map

package/dist/__test__/fixtures/graphs/two-department.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"two-department.d.ts","sourceRoot":"","sources":["../../../../src/__test__/fixtures/graphs/two-department.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,wBAAgB,0BAA0B,IAAI,gBAAgB,CAwI7D"}

package/dist/__test__/fixtures/graphs/typed-entity.d.ts

@@ -0,0 +1,3 @@
+import { TestGraphFixture } from '../types';
+export declare function createTypedEntityFixture(): TestGraphFixture;
+//# sourceMappingURL=typed-entity.d.ts.map

package/dist/__test__/fixtures/graphs/typed-entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-entity.d.ts","sourceRoot":"","sources":["../../../../src/__test__/fixtures/graphs/typed-entity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,wBAAgB,wBAAwB,IAAI,gBAAgB,CAqG3D"}

package/dist/__test__/fixtures/helpers.d.ts

@@ -0,0 +1,66 @@
+import { NodeId, ReadableGraph, NodeData, EdgeData } from '../../graph';
+import { ExpansionPath } from '../../expansion';
+import { MIFunction } from '../../ranking/mi';
+/**
+ * Create an ExpansionPath from an array of node IDs.
+ *
+ * The first node becomes the source seed and the last becomes the target seed.
+ * Useful for constructing paths in tests without manually creating Seed objects.
+ *
+ * @param nodes - Array of node IDs forming the path (must have at least 1 element)
+ * @returns ExpansionPath with fromSeed and toSeed inferred from endpoints
+ *
+ * @example
+ * ```typescript
+ * const path = createPath(['A', 'B', 'C']);
+ * // path.fromSeed.id === 'A'
+ * // path.toSeed.id === 'C'
+ * // path.nodes === ['A', 'B', 'C']
+ * ```
+ */
+export declare function createPath(nodes: readonly NodeId[]): ExpansionPath;
+/**
+ * Compute the mean MI across all edges in a single path.
+ *
+ * Uses geometric mean to avoid length bias:
+ * M(P) = exp(1/k * sum(log(I(u_i, v_i)))) where k is the number of edges.
+ *
+ * For single-node paths (no edges), returns NaN.
+ * For empty paths, returns NaN.
+ *
+ * @param graph - Source graph
+ * @param path - The path to score
+ * @param mi - MI function to use
+ * @returns Geometric mean MI, or NaN if path has fewer than 2 nodes
+ *
+ * @example
+ * ```typescript
+ * const path = createPath(['A', 'B', 'C']);
+ * const score = pathMI(graph, path, jaccard);
+ * // score is geometric mean of MI(A,B) and MI(B,C)
+ * ```
+ */
+export declare function pathMI<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, path: ExpansionPath, mi: MIFunction<N, E>): number;
+/**
+ * Compute the mean MI across all edges in all paths.
+ *
+ * Aggregates MI scores across multiple paths by taking the mean
+ * of individual path MIs. Paths with no edges (single-node paths)
+ * are excluded from the calculation.
+ *
+ * @param graph - Source graph
+ * @param paths - Array of paths to score
+ * @param mi - MI function to use
+ * @returns Mean MI across all valid paths, or 0 if no valid paths
+ *
+ * @example
+ * ```typescript
+ * const paths = [
+ *   createPath(['A', 'B', 'C']),
+ *   createPath(['D', 'E']),
+ * ];
+ * const avgScore = meanPathMI(graph, paths, jaccard);
+ * ```
+ */
+export declare function meanPathMI<N extends NodeData, E extends EdgeData>(graph: ReadableGraph<N, E>, paths: readonly ExpansionPath[], mi: MIFunction<N, E>): number;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/__test__/fixtures/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/__test__/fixtures/helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,aAAa,CAiBlE;AAoBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAC5D,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,IAAI,EAAE,aAAa,EACnB,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAClB,MAAM,CAgCR;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,QAAQ,EAChE,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,EAAE,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAClB,MAAM,CAeR"}

package/dist/__test__/fixtures/helpers.unit.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Unit tests for fixture helpers.
+ *
+ * Validates path creation and MI calculation functions.
+ */
+export {};
+//# sourceMappingURL=helpers.unit.test.d.ts.map

package/dist/__test__/fixtures/helpers.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.unit.test.d.ts","sourceRoot":"","sources":["../../../src/__test__/fixtures/helpers.unit.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/__test__/fixtures/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Test fixtures infrastructure.
+ *
+ * Provides types, helpers, and graph builders for integration tests
+ * across expansion, ranking, and other algorithms.
+ */
+export * from './types';
+export * from './helpers';
+export * from './graphs';
+//# sourceMappingURL=index.d.ts.map

package/dist/__test__/fixtures/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/__test__/fixtures/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC"}

package/dist/__test__/fixtures/types.d.ts

@@ -0,0 +1,35 @@
+import { NodeData, EdgeData, ReadableGraph } from '../../graph';
+import { Seed } from '../../expansion';
+/**
+ * Knowledge graph node with optional label and type.
+ */
+export interface KGNode extends NodeData {
+    /** Human-readable label for the node */
+    readonly label: string;
+    /** Optional semantic type (e.g., 'person', 'organisation') */
+    readonly type?: string;
+}
+/**
+ * Knowledge graph edge with optional weight and type.
+ */
+export interface KGEdge extends EdgeData {
+    /** Edge weight (default 1 for unweighted graphs) */
+    readonly weight?: number;
+    /** Optional semantic edge type (e.g., 'knows', 'mentors', 'cites') */
+    readonly type?: string;
+}
+/**
+ * Test graph fixture: graph, seeds, and metadata.
+ *
+ * Provides a complete test context including the graph,
+ * initial seed nodes, and optional metadata about the fixture's properties.
+ */
+export interface TestGraphFixture {
+    /** The test graph */
+    readonly graph: ReadableGraph;
+    /** Seed nodes for expansion */
+    readonly seeds: readonly Seed[];
+    /** Optional metadata about the fixture (e.g. structure description) */
+    readonly metadata: Record<string, unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/__test__/fixtures/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/__test__/fixtures/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,MAAO,SAAQ,QAAQ;IACvC,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,MAAO,SAAQ,QAAQ;IACvC,oDAAoD;IACpD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAChC,qBAAqB;IACrB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,+BAA+B;IAC/B,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC3C"}

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

@@ -1 +1 @@
-{"version":3,"file":"dome.d.ts","sourceRoot":"","sources":["../../src/expansion/dome.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAGjB;;;;;;;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,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,eAAe,CAejB;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,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,eAAe,CAejB"}
+{"version":3,"file":"dome.d.ts","sourceRoot":"","sources":["../../src/expansion/dome.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAGjB;;;;;;;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,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,eAAe,CAajB;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,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,eAAe,CAajB"}

package/dist/expansion/dome.integration.test.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Integration test for DOME expansion algorithm.
+ *
+ * DOME demonstrates hub deferral: it defers exploration of high-degree nodes
+ * and prioritises low-degree frontier expansion, discovering paths through
+ * sparse regions before exhausting hub-centric neighbours.
+ *
+ * This test uses a social network with a hub (Alice, degree 10+) and niche
+ * interest clusters. Bob (photography cluster) and Grace (hiking cluster) are
+ * separated and can be reached via two paths:
+ * - Hub path: bob → alice → grace (2 hops, alice degree 10)
+ * - Niche path: bob → carol → emma → grace (3 hops, carol/emma degree 3-4)
+ *
+ * DOME should discover the niche path first by deferring alice; standardBfs
+ * should discover the hub path first by expanding distance-1 neighbours.
+ */
+export {};
+//# sourceMappingURL=dome.integration.test.d.ts.map

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

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

package/dist/expansion/edge.d.ts

@@ -1,10 +1,10 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { Seed, ExpansionResult, ExpansionConfig } from './types';
 /**
- * Run EDGE expansion algorithm.
+ * Run EDGE expansion (Entropy-Driven Graph Expansion).
  *
- * Expands from seeds prioritising low-degree edges first.
- * Useful for avoiding hubs and exploring sparse regions.
+ * Discovers paths by prioritising nodes with diverse neighbour types,
+ * deferring nodes with homogeneous neighbourhoods.
  *
  * @param graph - Source graph
  * @param seeds - Seed nodes for expansion

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

@@ -1 +1 @@
-{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../src/expansion/edge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAwBjB;;;;;;;;;;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,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,eAAe,CAKjB"}
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../src/expansion/edge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAgCjB;;;;;;;;;;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,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5B,eAAe,CAKjB"}

package/dist/expansion/edge.integration.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Integration test for EDGE expansion algorithm.
+ *
+ * EDGE discovers paths by prioritising nodes with diverse neighbour types.
+ * High entropy (heterogeneous neighbourhoods) are expanded before low entropy
+ * (homogeneous neighbourhoods).
+ *
+ * This test demonstrates EDGE's behaviour on a graph with mixed node types.
+ */
+export {};
+//# sourceMappingURL=edge.integration.test.d.ts.map

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

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

package/dist/expansion/flux.d.ts

@@ -0,0 +1,25 @@
+import { NodeData, EdgeData, ReadableGraph } from '../graph';
+import { Seed, ExpansionResult, ExpansionConfig } from './types';
+/**
+ * Configuration for MAZE expansion.
+ */
+export interface MAZEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<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.
+ *
+ * Adaptively switches between expansion strategies based on
+ * local graph structure. Useful for heterogeneous graphs
+ * with varying density.
+ *
+ * @param graph - Source graph
+ * @param seeds - Seed nodes for expansion
+ * @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;
+//# sourceMappingURL=flux.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flux.d.ts","sourceRoot":"","sources":["../../src/expansion/flux.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAGjB;;GAEG;AACH,MAAM,WAAW,UAAU,CAC1B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9B,kEAAkE;IAClE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,iEAAiE;IACjE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CAClC;AA8FD;;;;;;;;;;;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,eAAe,CAcjB"}

package/dist/expansion/flux.integration.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Integration test for FLUX expansion algorithm.
+ *
+ * FLUX (Multi-phase Adaptive Zone Exploration) combines PIPE (phase 1),
+ * SAGE (phase 2), and adaptive termination to discover paths across regions
+ * of varying density. It switches strategies based on local structure and
+ * discovers more paths than single-strategy algorithms.
+ *
+ * This test uses a three-density network (city, suburban, village). FLUX
+ * should discover paths through all regions and total paths ≥ DOME/EDGE
+ * because it adapts strategy to local density.
+ */
+export {};
+//# sourceMappingURL=flux.integration.test.d.ts.map

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

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

package/dist/expansion/flux.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=flux.unit.test.d.ts.map

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

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

package/dist/expansion/fuse.d.ts

@@ -0,0 +1,28 @@
+import { NodeData, EdgeData, ReadableGraph } from '../graph';
+import { Seed, ExpansionResult, ExpansionConfig } from './types';
+/**
+ * Configuration for FUSE expansion.
+ */
+export interface FUSEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<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) */
+    readonly salienceWeight?: number;
+}
+/**
+ * @deprecated Use {@link FUSEConfig} instead.
+ */
+export type SAGEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> = FUSEConfig<N, E>;
+/**
+ * Run FUSE expansion 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 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;
+//# sourceMappingURL=fuse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fuse.d.ts","sourceRoot":"","sources":["../../src/expansion/fuse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAIjB;;GAEG;AACH,MAAM,WAAW,UAAU,CAC1B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9B,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;AAyCrB;;;;;;;;;;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,eAAe,CAUjB"}

package/dist/expansion/fuse.integration.test.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Integration test for FUSE expansion algorithm.
+ *
+ * FUSE (Salience-guided Adaptive Graph Expansion) is a two-phase algorithm
+ * that accumulates salience feedback from discovered paths. Early high-MI paths
+ * guide later exploration, causing FUSE to discover more high-quality paths
+ * than single-phase algorithms like DOME within the same node budget.
+ *
+ * This test uses the quality-vs-popularity network where two paths exist:
+ * one via a famous hub (low MI) and one via specialist clusters (high MI).
+ * FUSE should preferentially discover the specialist path due to salience
+ * accumulation.
+ */
+export {};
+//# sourceMappingURL=fuse.integration.test.d.ts.map

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

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

package/dist/expansion/fuse.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fuse.unit.test.d.ts.map

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

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

package/dist/expansion/hae.d.ts

@@ -1,21 +1,21 @@
 import { NodeData, EdgeData, ReadableGraph } from '../graph';
 import { Seed, ExpansionResult, ExpansionConfig } from './types';
 /**
- * Configuration for HAE expansion.
+ * Configuration for HAE, extending base ExpansionConfig.
  */
 export interface HAEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<N, E> {
-    /** MI function for computing edge priorities (default: jaccard) */
-    readonly mi?: (graph: ReadableGraph<N, E>, source: string, target: string) => number;
+    /** Function to extract type from a node (default: node.type) */
+    readonly typeMapper?: (node: N) => string;
 }
 /**
- * Run HAE expansion algorithm.
+ * Run HAE expansion (Heterogeneity-Aware Expansion).
  *
- * Expands from seeds prioritising high-MI edges.
- * Useful for finding paths with strong semantic associations.
+ * 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 config - Expansion configuration with MI function
+ * @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;

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

@@ -1 +1 @@
-{"version":3,"file":"hae.d.ts","sourceRoot":"","sources":["../../src/expansion/hae.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAIjB;;GAEG;AACH,MAAM,WAAW,SAAS,CACzB,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9B,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;AA0CD;;;;;;;;;;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,eAAe,CAUjB"}
+{"version":3,"file":"hae.d.ts","sourceRoot":"","sources":["../../src/expansion/hae.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAMjB;;GAEG;AACH,MAAM,WAAW,SAAS,CACzB,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9B,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,eAAe,CAOjB"}

package/dist/expansion/hae.integration.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Integration test for HAE expansion algorithm.
+ *
+ * HAE (Heterogeneity-Aware Expansion) generalises EDGE by allowing
+ * custom type extraction via a user-supplied typeMapper function.
+ *
+ * This test demonstrates HAE's ability to use custom type definitions
+ * beyond the default node.type property.
+ */
+export {};
+//# sourceMappingURL=hae.integration.test.d.ts.map

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

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

package/dist/expansion/index.d.ts

@@ -15,6 +15,12 @@ export * from './pipe';
 export * from './sage';
 export * from './reach';
 export * from './maze';
+export * from './tide';
+export * from './lace';
+export * from './warp';
+export * from './fuse';
+export * from './sift';
+export * from './flux';
 export * from './standard-bfs';
 export * from './frontier-balanced';
 export * from './random-priority';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/expansion/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,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/expansion/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"}

package/dist/expansion/lace.d.ts

@@ -0,0 +1,22 @@
+import { NodeData, EdgeData, ReadableGraph } from '../graph';
+import { Seed, ExpansionResult, ExpansionConfig } from './types';
+/**
+ * Configuration for LACE expansion.
+ */
+export interface LACEConfig<N extends NodeData = NodeData, E extends EdgeData = EdgeData> extends ExpansionConfig<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.
+ *
+ * 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 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;
+//# sourceMappingURL=lace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lace.d.ts","sourceRoot":"","sources":["../../src/expansion/lace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAClE,OAAO,KAAK,EACX,IAAI,EACJ,eAAe,EACf,eAAe,EAEf,MAAM,SAAS,CAAC;AAIjB;;GAEG;AACH,MAAM,WAAW,UAAU,CAC1B,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAC7B,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAC5B,SAAQ,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9B,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;AA0CD;;;;;;;;;;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,eAAe,CAUjB"}

package/dist/expansion/lace.integration.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Integration test for LACE expansion algorithm.
+ *
+ * LACE (Local Adaptive Community Entropy) is a single-phase algorithm that uses
+ * a user-supplied entropy function for node prioritisation. Unlike TIDE
+ * (which computes neighbourhood type entropy), LACE generalises to arbitrary
+ * entropy measures.
+ *
+ * This test demonstrates that LACE with an MI-based entropy function discovers
+ * paths with higher mean MI than DOME (which uses degree-based priority).
+ * LACE's pure MI prioritisation should prefer quality edges over high-degree hubs.
+ */
+export {};
+//# sourceMappingURL=lace.integration.test.d.ts.map