graphbox 1.2.1 → 1.3.0

package/README.md

@@ -1,5 +1,7 @@
 # GraphBox
 
+This file provides guidance to Claude Code (claude.ai/code) when working with this repository.
+
 **GraphBox** = Graph Sandbox + Graph Toolbox
 
 Abstract and experimental graph algorithms for academic research. The name reflects its dual purpose:
@@ -23,14 +25,31 @@ GraphBox consolidates three previously separate BibGraph packages into a single,
 pnpm install graphbox
 ```
 
-## CLI
+## Commands
 
 ```bash
+# Development
+pnpm install              # Install dependencies
+pnpm typecheck            # TypeScript type checking
+pnpm lint                 # ESLint with auto-fix
+pnpm test                 # Run unit tests with coverage
+pnpm build                # Build library + CLI
+
+# Experiments (high memory required)
+NODE_OPTIONS="--max-old-space-size=8192" pnpm test:metrics    # Run experiments, generate metrics
+pnpm gen:latex-tables                                     # Generate LaTeX tables from metrics
+pnpm update:thesis-tables                                  # Full: experiments + LaTeX table generation
+
+# Standalone experiment orchestrator
+npx tsx src/experiments/run-experiments.ts                 # Run all experiments
+npx tsx src/experiments/run-experiments.ts --output path   # Custom output path
+
+# CLI
 npx graphbox help       # Show available commands
 npx graphbox version    # Show version
-npx graphbox generate   # Generate a graph from a specification
+npx graphbox generate   # Generate graphs from specifications
 npx graphbox analyze    # Analyze graph properties
-npx graphbox validate   # Validate a graph against constraints
+npx graphbox validate   # Validate graphs against constraints
 ```
 
 ## Key Features
@@ -105,58 +124,70 @@ import { validateGraph, checkConstraints } from 'graphbox';
 const isValid = validateGraph(graph, constraints);
 ```
 
-## Usage Examples
+## Architecture
 
-### Basic Traversal
+### Experiment Framework
 
-```typescript
-import { GraphAdapter, bfs } from 'graphbox';
+The evaluation harness provides **reusable, repeatable, reproducible** experiments:
 
-const graph = { /* your graph */ };
-const adapter = new GraphAdapter(graph);
+1. **`src/experiments/run-experiments.ts`** - Orchestrator that runs all experiments
+2. **`src/experiments/metrics/`** - Typed metrics collection system
+   - `types.ts` - All metric type interfaces (must conform for table generation)
+   - `collector.ts` - `MetricsCollector` class for recording metrics
+   - `storage.ts` - File I/O for `test-metrics.json`
+3. **`src/experiments/experiments/`** - Standalone experiment scripts
+   - `bidirectional-bfs.ts` - Degree-Prioritised vs baselines
+   - `seeded-expansion.ts` - N=1 ego-network, N=2 bidirectional, N>=3 multi-seed
+   - `path-ranking.ts` - Path Salience Ranking with MI-based ranking
 
-const result = bfs(adapter, 'startNodeId');
-console.log(result.visited); // Array of visited node IDs
-```
+4. **`scripts/export-csv.ts`** - Exports metrics as per-category CSV files for pgfplotstable
 
-### Ego Network Extraction
+**Pipeline:** Experiments → MetricsCollector → test-metrics.json → CSV files → LaTeX pgfplotstable
 
-```typescript
-import { extractEgoNetwork } from 'graphbox';
+### Three Algorithms Evaluated
 
-const adapter = new GraphAdapter(graph);
+1. **Seeded Node Expansion**
+   - N=1: Ego-network extraction
+   - N=2: Bidirectional path finding
+   - N>=3: Multi-seed expansion
 
-const egoNetwork = extractEgoNetwork(adapter, {
-  radius: 2,
-  seedNodes: ['author123'],
-  includeEdgeWeights: true
-});
+2. **Bidirectional BFS** (Degree-Prioritised Expansion)
+   - Degree-based prioritisation vs standard BFS, frontier-balanced, random priority
+   - Hub explosion mitigation
 
-console.log(egoNetwork);
-```
+3. **Salient Path Selection**
+   - Mutual Information (MI) based path ranking
+   - Statistical significance testing (Mann-Whitney U, Cohen's d)
 
-### Graph Generation
+### Graph Abstraction
 
-```typescript
-import { generateGraph, GraphSpec } from 'graphbox';
+- **`ReadableGraph<N, E>`** - Minimal interface for graph traversal
+- **`GraphAdapter`** - Adapter pattern for different graph implementations
+- **`GraphExpander`** - Interface for dynamic graph expansion (used by algorithms)
+- **`BenchmarkGraphExpander`** - Wraps loaded benchmark graphs for algorithm compatibility
 
-const spec: GraphSpec = {
-  type: 'complete',
-  nodeCount: 50,
-  edgeDensity: 0.15
-};
+### Path Aliases
 
-const graph = generateGraph(spec);
+TypeScript paths configured in `tsconfig.json`:
+```typescript
+@graph/algorithms/*    → src/algorithms/*
+@graph/interfaces/*    → src/interfaces/*
+@graph/evaluation/*    → src/experiments/evaluation/*
+@graph/experiments/*   → src/experiments/*
 ```
 
-### Graph Validation
+### Test Organization
 
-```typescript
-import { validateGraph } from 'graphbox';
+- **`.exp.integration.test.ts`** - Experiment tests (high memory, use `--max-old-space-size=8192`)
+- **Unit tests** - Co-located with algorithms
+- **Benchmarks** - `src/experiments/evaluation/__tests__/validation/*/benchmarks/`
+- **Fixtures** - `src/experiments/evaluation/__tests__/validation/*/fixtures/`
 
-const graph = { /* graph object */ };
-const isValid = validateGraph(graph);
-```
+## Build System
+
+**Dual build targets** via Vite:
+- **Library**: ES modules, CJS, UMD formats (browser-compatible)
+- **CLI**: ESM-only for Node.js command-line interface
 
 ## API Reference
 
@@ -182,6 +213,34 @@ const isValid = validateGraph(graph);
 - **generateGraph(spec)** - Generate graph from specification
 - **validateGraph(graph, constraints)** - Validate graph against constraints
 
+## Key Constraints
+
+- **Never use `any`** - Use `unknown` with type guards
+- **Serial test execution** - Parallel causes OOM on large graphs
+- **Memory limits** - Use `NODE_OPTIONS="--max-old-space-size=8192"` for experiments
+- **Metric types** - All metrics must conform to types in `src/experiments/metrics/types.ts`
+
+## LaTeX Table Generation
+
+The experiment pipeline can generate LaTeX tables (`.tex` files) consumable by `pgfplotstable`.
+
+Table-to-metric mapping:
+| Table | Metric Category |
+|-------|-----------------|
+| 06-runtime-performance.tex | runtime-performance |
+| 06-path-lengths.tex | path-lengths |
+| 06-scalability.tex | scalability |
+| 06-n-seed-hub-traversal.tex | n-seed-hub-traversal |
+| 06-statistical-significance.tex | statistical-significance |
+| 06-cross-dataset.tex | cross-dataset |
+| 06-method-ranking.tex | method-ranking |
+| 06-structural-representativeness.tex | structural-representativeness |
+| 06-n-seed-generalisation.tex | n-seed-generalization |
+| 06-n-seed-comparison.tex | n-seed-comparison |
+| 06-n-seed-path-diversity.tex | n-seed-path-diversity |
+| 06-structural-representativeness-metrics.tex | structural-representativeness-metrics |
+| 06-mi-ranking-quality.tex | mi-ranking-quality |
+
 ## Contributing
 
 This package is part of academic research work. Contributions are welcome, please open an issue first.
@@ -196,6 +255,4 @@ Joe Mearman
 
 ## Related Projects
 
-- **BibGraph**: Main BibGraph monorepo
-- **algorithms**: Graph algorithms package for BibGraph
-- **types**: Shared TypeScript types for BibGraph
+- **[BibGraph](https://github.com/Mearman/BibGraph)** - React SPA for OpenAlex literature discovery

package/dist/__tests__/integration/bipartite.integration.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration tests for Bipartite graph class
+ *
+ * Bipartite: vertices can be partitioned into two disjoint sets
+ * such that every edge connects a vertex in one set to one in the other.
+ * Equivalent: graph contains no odd-length cycles.
+ */
+export {};
+//# sourceMappingURL=bipartite.integration.test.d.ts.map

package/dist/__tests__/integration/bipartite.integration.test.d.ts.map

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

package/dist/__tests__/integration/chordal.integration.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration tests for Chordal graph class
+ *
+ * Chordal: every cycle of length >= 4 has a chord (edge between non-adjacent vertices).
+ * Equivalent: has a perfect elimination ordering.
+ * Examples: trees, complete graphs, interval graphs.
+ */
+export {};
+//# sourceMappingURL=chordal.integration.test.d.ts.map

package/dist/__tests__/integration/chordal.integration.test.d.ts.map

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

package/dist/__tests__/integration/cliquewidth.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for cliquewidth-bounded graphs.
+ *
+ * Tests the complete pipeline: spec → generation → analysis → validation
+ * for cliquewidth graph property.
+ */
+export {};
+//# sourceMappingURL=cliquewidth.integration.test.d.ts.map

package/dist/__tests__/integration/cliquewidth.integration.test.d.ts.map

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

package/dist/__tests__/integration/cograph.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Cograph graph class
+ *
+ * Cograph: P4-free graph (contains no induced path on 4 vertices).
+ * Can be constructed recursively using disjoint union and complement operations.
+ */
+export {};
+//# sourceMappingURL=cograph.integration.test.d.ts.map

package/dist/__tests__/integration/cograph.integration.test.d.ts.map

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

package/dist/__tests__/integration/comparability.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Comparability graph class
+ *
+ * Comparability: edges can be transitively oriented (partial order).
+ * Equivalent: intersection graph of a family of sets ordered by inclusion.
+ */
+export {};
+//# sourceMappingURL=comparability.integration.test.d.ts.map

package/dist/__tests__/integration/comparability.integration.test.d.ts.map

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

package/dist/__tests__/integration/eulerian.integration.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration tests for Eulerian graph class
+ *
+ * Eulerian: has a circuit that visits every edge exactly once.
+ * Equivalent: connected graph where all vertices have even degree.
+ * Semi-Eulerian: has a trail (not circuit) visiting every edge exactly once.
+ */
+export {};
+//# sourceMappingURL=eulerian.integration.test.d.ts.map

package/dist/__tests__/integration/eulerian.integration.test.d.ts.map

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

package/dist/__tests__/integration/hamiltonian.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Hamiltonian graph class
+ *
+ * Hamiltonian: has a cycle that visits every vertex exactly once.
+ * Determining Hamiltonicity is NP-complete.
+ */
+export {};
+//# sourceMappingURL=hamiltonian.integration.test.d.ts.map

package/dist/__tests__/integration/hamiltonian.integration.test.d.ts.map

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

package/dist/__tests__/integration/helpers.d.ts

@@ -0,0 +1,8 @@
+import { AnalyzerGraph } from '../../analyzer/types';
+import { TestGraph } from '../../generation/generator';
+/**
+ * Convert a TestGraph to an AnalyzerGraph for classification.
+ * @param testGraph
+ */
+export declare const toAnalyzerGraph: (testGraph: TestGraph) => AnalyzerGraph;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/__tests__/integration/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/__tests__/integration/helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAgB,aAAa,EAAkB,MAAM,sBAAsB,CAAC;AACxF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,WAAW,SAAS,KAAG,aAiBtD,CAAC"}

package/dist/__tests__/integration/interval.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Interval graph class
+ *
+ * Interval: can be represented as intersection graph of intervals on the real line.
+ * Interval graphs are chordal.
+ */
+export {};
+//# sourceMappingURL=interval.integration.test.d.ts.map

package/dist/__tests__/integration/interval.integration.test.d.ts.map

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

package/dist/__tests__/integration/modular.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for modular graphs.
+ *
+ * Tests the complete pipeline: spec → generation → analysis → validation
+ * for modular graph property.
+ */
+export {};
+//# sourceMappingURL=modular.integration.test.d.ts.map

package/dist/__tests__/integration/modular.integration.test.d.ts.map

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

package/dist/__tests__/integration/pathwidth.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for pathwidth-bounded graphs.
+ *
+ * Tests the complete pipeline: spec → generation → analysis → validation
+ * for pathwidth graph property.
+ */
+export {};
+//# sourceMappingURL=pathwidth.integration.test.d.ts.map

package/dist/__tests__/integration/pathwidth.integration.test.d.ts.map

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

package/dist/__tests__/integration/perfect.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Perfect graph class
+ *
+ * Perfect: ω(H) = χ(H) for all induced subgraphs H (clique number = chromatic number).
+ * Examples: chordal, bipartite, cograph.
+ */
+export {};
+//# sourceMappingURL=perfect.integration.test.d.ts.map

package/dist/__tests__/integration/perfect.integration.test.d.ts.map

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

package/dist/__tests__/integration/permutation.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Permutation graph class
+ *
+ * Permutation: intersection graph of line segments between two parallel lines.
+ * Permutation graphs are comparability graphs and co-comparability graphs.
+ */
+export {};
+//# sourceMappingURL=permutation.integration.test.d.ts.map

package/dist/__tests__/integration/permutation.integration.test.d.ts.map

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

package/dist/__tests__/integration/planar.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for planar graphs.
+ *
+ * Tests the complete pipeline: spec → generation → analysis → validation
+ * for planar graph property.
+ */
+export {};
+//# sourceMappingURL=planar.integration.test.d.ts.map

package/dist/__tests__/integration/planar.integration.test.d.ts.map

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

package/dist/__tests__/integration/ptolemaic.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for ptolemaic graphs.
+ *
+ * Tests the complete pipeline: spec → generation → analysis → validation
+ * for ptolemaic graph property.
+ */
+export {};
+//# sourceMappingURL=ptolemaic.integration.test.d.ts.map

package/dist/__tests__/integration/ptolemaic.integration.test.d.ts.map

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

package/dist/__tests__/integration/quasiline.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for quasi-line graphs.
+ *
+ * Tests the complete pipeline: spec → generation → analysis → validation
+ * for quasi-line graph property.
+ */
+export {};
+//# sourceMappingURL=quasiline.integration.test.d.ts.map

package/dist/__tests__/integration/quasiline.integration.test.d.ts.map

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

package/dist/__tests__/integration/regular.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Regular graph class
+ *
+ * Regular: all vertices have the same degree k.
+ * Special cases: cubic (3-regular), cycle (2-regular).
+ */
+export {};
+//# sourceMappingURL=regular.integration.test.d.ts.map

package/dist/__tests__/integration/regular.integration.test.d.ts.map

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

package/dist/__tests__/integration/split.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Split graph class
+ *
+ * Split: vertices can be partitioned into a clique K and an independent set I.
+ * Split graphs are chordal.
+ */
+export {};
+//# sourceMappingURL=split.integration.test.d.ts.map

package/dist/__tests__/integration/split.integration.test.d.ts.map

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

package/dist/__tests__/integration/tree.integration.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Integration tests for Tree graph class
+ *
+ * Tree: undirected, acyclic, connected graph
+ * Properties: |E| = |V| - 1, unique path between any two vertices
+ */
+export {};
+//# sourceMappingURL=tree.integration.test.d.ts.map

package/dist/__tests__/integration/tree.integration.test.d.ts.map

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

package/dist/algorithms/analysis/connected-components.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for connected components algorithm
+ */
+export {};
+//# sourceMappingURL=connected-components.unit.test.d.ts.map

package/dist/algorithms/analysis/connected-components.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connected-components.unit.test.d.ts","sourceRoot":"","sources":["../../../src/algorithms/analysis/connected-components.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/algorithms/analysis/cycle-detection.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for cycle detection algorithm
+ */
+export {};
+//# sourceMappingURL=cycle-detection.unit.test.d.ts.map

package/dist/algorithms/analysis/cycle-detection.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle-detection.unit.test.d.ts","sourceRoot":"","sources":["../../../src/algorithms/analysis/cycle-detection.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/algorithms/analysis/scc.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for strongly connected components (Tarjan's algorithm)
+ */
+export {};
+//# sourceMappingURL=scc.unit.test.d.ts.map

package/dist/algorithms/analysis/scc.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scc.unit.test.d.ts","sourceRoot":"","sources":["../../../src/algorithms/analysis/scc.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/algorithms/analysis/topological-sort.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for topological sort algorithm
+ */
+export {};
+//# sourceMappingURL=topological-sort.unit.test.d.ts.map

package/dist/algorithms/analysis/topological-sort.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"topological-sort.unit.test.d.ts","sourceRoot":"","sources":["../../../src/algorithms/analysis/topological-sort.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/algorithms/clustering/infomap.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for Infomap community detection algorithm
+ */
+export {};
+//# sourceMappingURL=infomap.unit.test.d.ts.map

package/dist/algorithms/clustering/infomap.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infomap.unit.test.d.ts","sourceRoot":"","sources":["../../../src/algorithms/clustering/infomap.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/algorithms/clustering/label-propagation.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for Label Propagation clustering algorithm
+ */
+export {};
+//# sourceMappingURL=label-propagation.unit.test.d.ts.map

package/dist/algorithms/clustering/label-propagation.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"label-propagation.unit.test.d.ts","sourceRoot":"","sources":["../../../src/algorithms/clustering/label-propagation.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/algorithms/clustering/leiden.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for Leiden community detection algorithm
+ */
+export {};
+//# sourceMappingURL=leiden.unit.test.d.ts.map

package/dist/algorithms/clustering/leiden.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leiden.unit.test.d.ts","sourceRoot":"","sources":["../../../src/algorithms/clustering/leiden.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/algorithms/clustering/louvain.d.ts

@@ -2,6 +2,22 @@ import { Graph } from '../graph/graph';
 import { Community } from '../types/clustering-types';
 import { Edge, Node } from '../types/graph';
 import { WeightFunction } from '../types/weight-function';
+/**
+ * Result of Louvain community detection including performance statistics.
+ */
+export interface LouvainResult<N extends Node> {
+    /** Detected communities */
+    communities: Community<N>[];
+    /** Performance and convergence statistics */
+    stats: {
+        /** Total iterations across all hierarchy levels */
+        totalIterations: number;
+        /** Number of hierarchy levels processed */
+        hierarchyLevels: number;
+        /** Runtime in milliseconds */
+        runtimeMs: number;
+    };
+}
 /**
  * Get adaptive convergence threshold based on graph size.
  * @param nodeCount - Number of nodes in graph
@@ -86,17 +102,17 @@ export declare const shuffle: <T>(array: T[], seed?: number) => T[];
  * // ... add nodes and edges ...
  *
  * // Basic usage (adaptive defaults)
- * const communities = detectCommunities(graph);
- * console.log(`Found ${communities.length} communities`);
+ * const { communities, stats } = detectCommunities(graph);
+ * console.log(`Found ${communities.length} communities in ${stats.totalIterations} iterations`);
  *
  * // Quality-first mode
- * const qualityCommunities = detectCommunities(graph, { mode: "best" });
+ * const result = detectCommunities(graph, { mode: "best" });
  *
  * // Speed-first mode for large graphs
- * const fastCommunities = detectCommunities(graph, { mode: "random", maxIterations: 10 });
+ * const fast = detectCommunities(graph, { mode: "random", maxIterations: 10 });
  *
  * // Reproducible results
- * const deterministicCommunities = detectCommunities(graph, { seed: 42 });
+ * const deterministic = detectCommunities(graph, { seed: 42 });
  * ```
  */
 export declare const detectCommunities: <N extends Node, E extends Edge>(graph: Graph<N, E>, options?: {
@@ -106,5 +122,5 @@ export declare const detectCommunities: <N extends Node, E extends Edge>(graph:
     seed?: number;
     minModularityIncrease?: number;
     maxIterations?: number;
-}) => Community<N>[];
+}) => LouvainResult<N>;
 //# sourceMappingURL=louvain.d.ts.map

package/dist/algorithms/clustering/louvain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"louvain.d.ts","sourceRoot":"","sources":["../../../src/algorithms/clustering/louvain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAC,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAa/D;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,KAAG,MAAuC,CAAC;AAEjG;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,WAAW,MAAM,EAAE,OAAO,MAAM,KAAG,MAK5E,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,QAAO,MAAM,GAAG,QAAkB,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,OAAO,MAAM,KAAG,CAAC,EAsBvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,IAAI,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAS;IAC9F,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;CAClB,KAAG,SAAS,CAAC,CAAC,CAAC,EAwXpB,CAAC"}
+{"version":3,"file":"louvain.d.ts","sourceRoot":"","sources":["../../../src/algorithms/clustering/louvain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,IAAI,EAAC,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAG/D;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,IAAI;IAC5C,2BAA2B;IAC3B,WAAW,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IAC5B,6CAA6C;IAC7C,KAAK,EAAE;QACN,mDAAmD;QACnD,eAAe,EAAE,MAAM,CAAC;QACxB,2CAA2C;QAC3C,eAAe,EAAE,MAAM,CAAC;QACxB,8BAA8B;QAC9B,SAAS,EAAE,MAAM,CAAC;KAClB,CAAC;CACF;AAYD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,KAAG,MAAuC,CAAC;AAEjG;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,WAAW,MAAM,EAAE,OAAO,MAAM,KAAG,MAK5E,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,QAAO,MAAM,GAAG,QAAkB,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,OAAO,MAAM,KAAG,CAAC,EAsBvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,IAAI,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAS;IAC9F,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;CAClB,KAAG,aAAa,CAAC,CAAC,CAkZvB,CAAC"}

package/dist/algorithms/clustering/louvain.unit.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for Louvain community detection algorithm
+ */
+export {};
+//# sourceMappingURL=louvain.unit.test.d.ts.map

package/dist/algorithms/clustering/louvain.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"louvain.unit.test.d.ts","sourceRoot":"","sources":["../../../src/algorithms/clustering/louvain.unit.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/algorithms/decomposition/biconnected.unit.test.d.ts

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

package/dist/algorithms/decomposition/biconnected.unit.test.d.ts.map

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

package/dist/algorithms/decomposition/core-periphery.unit.test.d.ts

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

package/dist/algorithms/decomposition/core-periphery.unit.test.d.ts.map

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

package/dist/algorithms/decomposition/k-core.unit.test.d.ts

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

package/dist/algorithms/decomposition/k-core.unit.test.d.ts.map

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