agentic-qe 3.13.9 → 3.13.11

package/dist/integrations/ruvector/index.js

@@ -30,44 +30,44 @@
  * ```
  */
 // Export constants
-export { DEFAULT_RUVECTOR_CONFIG } from './interfaces';
+export { DEFAULT_RUVECTOR_CONFIG } from './interfaces.js';
 // Export errors
-export { RuVectorError, RuVectorUnavailableError, RuVectorTimeoutError, RuVectorConfigError, } from './interfaces';
+export { RuVectorError, RuVectorUnavailableError, RuVectorTimeoutError, RuVectorConfigError, } from './interfaces.js';
 // ============================================================================
 // Factory Functions (Async - ML-first with observability)
 // ============================================================================
-export { createQLearningRouter, createQLearningRouterSync } from './q-learning-router';
-export { createASTComplexityAnalyzer, createASTComplexityAnalyzerSync } from './ast-complexity';
-export { createDiffRiskClassifier, createDiffRiskClassifierSync } from './diff-risk-classifier';
-export { createCoverageRouter, createCoverageRouterSync } from './coverage-router';
-export { createGraphBoundariesAnalyzer, createGraphBoundariesAnalyzerSync } from './graph-boundaries';
-export { createFallbackComponents } from './fallback';
+export { createQLearningRouter, createQLearningRouterSync } from './q-learning-router.js';
+export { createASTComplexityAnalyzer, createASTComplexityAnalyzerSync } from './ast-complexity.js';
+export { createDiffRiskClassifier, createDiffRiskClassifierSync } from './diff-risk-classifier.js';
+export { createCoverageRouter, createCoverageRouterSync } from './coverage-router.js';
+export { createGraphBoundariesAnalyzer, createGraphBoundariesAnalyzerSync } from './graph-boundaries.js';
+export { createFallbackComponents } from './fallback.js';
 // Persistent Q-Learning Router (ADR-046: Q-value persistence)
-export { createPersistentQLearningRouter, createPersistentQLearningRouterSync, } from './persistent-q-router';
+export { createPersistentQLearningRouter, createPersistentQLearningRouterSync, } from './persistent-q-router.js';
 // Persistent SONA Engine (ADR-046: SONA pattern persistence)
-export { createPersistentSONAEngine, createPersistentSONAEngineSync, } from './sona-persistence';
+export { createPersistentSONAEngine, createPersistentSONAEngineSync, } from './sona-persistence.js';
 // ============================================================================
 // Implementation Classes (for advanced usage)
 // ============================================================================
-export { RuVectorQLearningRouter } from './q-learning-router';
-export { RuVectorASTComplexityAnalyzer } from './ast-complexity';
-export { RuVectorDiffRiskClassifier } from './diff-risk-classifier';
-export { RuVectorCoverageRouter } from './coverage-router';
-export { RuVectorGraphBoundariesAnalyzer } from './graph-boundaries';
+export { RuVectorQLearningRouter } from './q-learning-router.js';
+export { RuVectorASTComplexityAnalyzer } from './ast-complexity.js';
+export { RuVectorDiffRiskClassifier } from './diff-risk-classifier.js';
+export { RuVectorCoverageRouter } from './coverage-router.js';
+export { RuVectorGraphBoundariesAnalyzer } from './graph-boundaries.js';
 // Persistent Q-Learning Router (ADR-046: Q-value persistence)
-export { PersistentQLearningRouter, DEFAULT_EWC_CONFIG, DEFAULT_PERSISTENT_CONFIG, } from './persistent-q-router';
+export { PersistentQLearningRouter, DEFAULT_EWC_CONFIG, DEFAULT_PERSISTENT_CONFIG, } from './persistent-q-router.js';
 // Persistent SONA Engine (ADR-046: SONA pattern persistence)
-export { PersistentSONAEngine, DEFAULT_PERSISTENT_SONA_CONFIG, SONA_PATTERNS_SCHEMA, SONA_FISHER_SCHEMA, } from './sona-persistence';
+export { PersistentSONAEngine, DEFAULT_PERSISTENT_SONA_CONFIG, SONA_PATTERNS_SCHEMA, SONA_FISHER_SCHEMA, } from './sona-persistence.js';
 // SONA Three-Loop Engine (Task 2.2: EWC++ & MicroLoRA)
-export { SONAThreeLoopEngine, MicroLoRA, EWCPlusPlus, createSONAThreeLoopEngine, DEFAULT_THREE_LOOP_CONFIG, } from './sona-three-loop';
+export { SONAThreeLoopEngine, MicroLoRA, EWCPlusPlus, createSONAThreeLoopEngine, DEFAULT_THREE_LOOP_CONFIG, } from './sona-three-loop.js';
 // Fallback implementations
-export { FallbackQLearningRouter, FallbackASTComplexityAnalyzer, FallbackDiffRiskClassifier, FallbackCoverageRouter, FallbackGraphBoundariesAnalyzer, } from './fallback';
-import { DEFAULT_RUVECTOR_CONFIG, RuVectorUnavailableError } from './interfaces';
-import { createQLearningRouter } from './q-learning-router';
-import { createASTComplexityAnalyzer } from './ast-complexity';
-import { createDiffRiskClassifier } from './diff-risk-classifier';
-import { createCoverageRouter } from './coverage-router';
-import { createGraphBoundariesAnalyzer } from './graph-boundaries';
+export { FallbackQLearningRouter, FallbackASTComplexityAnalyzer, FallbackDiffRiskClassifier, FallbackCoverageRouter, FallbackGraphBoundariesAnalyzer, } from './fallback.js';
+import { DEFAULT_RUVECTOR_CONFIG, RuVectorUnavailableError } from './interfaces.js';
+import { createQLearningRouter } from './q-learning-router.js';
+import { createASTComplexityAnalyzer } from './ast-complexity.js';
+import { createDiffRiskClassifier } from './diff-risk-classifier.js';
+import { createCoverageRouter } from './coverage-router.js';
+import { createGraphBoundariesAnalyzer } from './graph-boundaries.js';
 /**
  * Default RuVector client implementation
  * Provides unified access to all RuVector features with ML-first approach.
@@ -279,11 +279,11 @@ export async function getRuVectorStatus(config = {}) {
 // @ruvector Package Wrappers (SONA, Flash Attention, GNN)
 // ============================================================================
 // QE Wrappers for @ruvector packages
-export * from './wrappers';
+export * from './wrappers.js';
 // ============================================================================
 // Service Provider (Dependency Injection)
 // ============================================================================
-export { RuVectorServiceProvider, getDomainRuVectorServices, getRuVectorProvider, getRuVectorServiceAvailability, } from './provider';
+export { RuVectorServiceProvider, getDomainRuVectorServices, getRuVectorProvider, getRuVectorServiceAvailability, } from './provider.js';
 // ============================================================================
 // Feature Flags
 // ============================================================================
@@ -297,35 +297,35 @@ isMetaLearningEnabled, isSublinearSolverEnabled, isSpectralSparsificationEnabled
 // Phase 5 Milestone 4 (ADR-087)
 isEpropOnlineLearningEnabled, isGrangerCausalityEnabled, 
 // Phase 5 Milestone 5 (ADR-087)
-isCognitiveRoutingEnabled, isHyperbolicHnswEnabled, DEFAULT_FEATURE_FLAGS, } from './feature-flags';
+isCognitiveRoutingEnabled, isHyperbolicHnswEnabled, DEFAULT_FEATURE_FLAGS, } from './feature-flags.js';
 // ============================================================================
 // Cross-Domain Transfer Learning (ADR-084, Task 2.3)
 // ============================================================================
 export { DomainTransferEngine, ThompsonSampler, createDomainTransferEngine, DEFAULT_DOMAIN_TRANSFER_CONFIG, 
 // R7: Meta-Learning Enhancements (ADR-087, Milestone 3)
-DecayingBeta, PlateauDetector, ParetoFront, CuriosityBonus, } from './domain-transfer';
-export { TransferCoherenceStub, createTransferCoherenceGate, } from './transfer-coherence-stub';
-export { TransferVerifier, createTransferVerifier, DEFAULT_VERIFICATION_CONFIG, } from './transfer-verification';
+DecayingBeta, PlateauDetector, ParetoFront, CuriosityBonus, } from './domain-transfer.js';
+export { TransferCoherenceStub, createTransferCoherenceGate, } from './transfer-coherence-stub.js';
+export { TransferVerifier, createTransferVerifier, DEFAULT_VERIFICATION_CONFIG, } from './transfer-verification.js';
 // ============================================================================
 // Temporal Tensor Compression (ADR-085)
 // ============================================================================
-export { TemporalCompressionService, getTemporalCompressionService, createTemporalCompressionService, resetTemporalCompressionService, cosineSimilarity, TIER_CONFIG, THEORETICAL_COMPRESSION_RATIOS, ACTUAL_FALLBACK_RATIO, EXPECTED_COMPRESSION_RATIOS, HOT_THRESHOLD_DAYS, WARM_THRESHOLD_DAYS, } from './temporal-compression';
+export { TemporalCompressionService, getTemporalCompressionService, createTemporalCompressionService, resetTemporalCompressionService, cosineSimilarity, TIER_CONFIG, THEORETICAL_COMPRESSION_RATIOS, ACTUAL_FALLBACK_RATIO, EXPECTED_COMPRESSION_RATIOS, HOT_THRESHOLD_DAYS, WARM_THRESHOLD_DAYS, } from './temporal-compression.js';
 // ============================================================================
 // Hypergraph Schema (Neural Backbone)
 // ============================================================================
-export { HypergraphSchemaManager, nodeToRow, rowToNode, edgeToRow, rowToEdge, generateEdgeId, NODE_TYPES, EDGE_TYPES, } from './hypergraph-schema';
+export { HypergraphSchemaManager, nodeToRow, rowToNode, edgeToRow, rowToEdge, generateEdgeId, NODE_TYPES, EDGE_TYPES, } from './hypergraph-schema.js';
 // ============================================================================
 // Hypergraph Query Engine (Neural Backbone - GOAP Action 6)
 // ============================================================================
-export { HypergraphEngine, createHypergraphEngine, createHypergraphEngineSync, DEFAULT_HYPERGRAPH_ENGINE_CONFIG, } from './hypergraph-engine';
+export { HypergraphEngine, createHypergraphEngine, createHypergraphEngineSync, DEFAULT_HYPERGRAPH_ENGINE_CONFIG, } from './hypergraph-engine.js';
 // ============================================================================
 // ML Observability
 // ============================================================================
-export { RuVectorObservability, getRuVectorObservability, recordMLUsage, recordFallback, getObservabilityReport, } from './observability';
+export { RuVectorObservability, getRuVectorObservability, recordMLUsage, recordFallback, getObservabilityReport, } from './observability.js';
 // ============================================================================
 // RuVector Server Client (GOAP Action 8)
 // ============================================================================
-export { RuVectorServerClient, createRuVectorServerClient, createRuVectorServerClientSync, getSharedServerClient, resetSharedServerClient, DEFAULT_SERVER_CONFIG, } from './server-client';
+export { RuVectorServerClient, createRuVectorServerClient, createRuVectorServerClientSync, getSharedServerClient, resetSharedServerClient, DEFAULT_SERVER_CONFIG, } from './server-client.js';
 // ============================================================================
 // RVF Native Adapter (ADR-069: Native RVF Container Integration)
 // ============================================================================
@@ -335,52 +335,52 @@ export { getSharedRvfDualWriter, getSharedRvfDualWriterSync, resetSharedRvfDualW
 // ============================================================================
 // Cognitive Container Export/Import (Task 4.1: RVF v2)
 // ============================================================================
-export { CognitiveContainer, createCognitiveContainer, generateSigningKeyPair, } from './cognitive-container';
+export { CognitiveContainer, createCognitiveContainer, generateSigningKeyPair, } from './cognitive-container.js';
 // ============================================================================
 // Phase 5: Pattern Intelligence (ADR-087, Milestone 1)
 // ============================================================================
 // R1: HDC Pattern Fingerprinting
-export { HdcFingerprinter, createHdcFingerprinter, HDCPatternFingerprinter, createHDCFingerprinter, createRandomHypervector, bind, bundle, hammingDistance, hammingSimilarity, permute, } from './hdc-fingerprint';
+export { HdcFingerprinter, createHdcFingerprinter, HDCPatternFingerprinter, createHDCFingerprinter, createRandomHypervector, bind, bundle, hammingDistance, hammingSimilarity, permute, } from './hdc-fingerprint.js';
 // R2: CUSUM Drift Detection
-export { CusumDetector, } from './cusum-detector';
+export { CusumDetector, } from './cusum-detector.js';
 // R3: Delta Event Sourcing
-export { DeltaTracker, PATTERN_DELTAS_SCHEMA, } from './delta-tracker';
+export { DeltaTracker, PATTERN_DELTAS_SCHEMA, } from './delta-tracker.js';
 // R3: Sparse Vector Delta Event Sourcing (ADR-087 Milestone 1)
-export { VectorDeltaTracker, createVectorDeltaTracker, } from './vector-delta-tracker';
+export { VectorDeltaTracker, createVectorDeltaTracker, } from './vector-delta-tracker.js';
 // ============================================================================
 // Phase 5: Graph Learning (ADR-087, Milestone 2)
 // ============================================================================
 // R4: GraphMAE Self-Supervised Learning
-export { GraphMAEEncoder, createGraphMAEEncoder, } from './graphmae-encoder';
+export { GraphMAEEncoder, createGraphMAEEncoder, } from './graphmae-encoder.js';
 // R5: Modern Hopfield Networks
-export { HopfieldMemory, createHopfieldMemory, } from './hopfield-memory';
+export { HopfieldMemory, createHopfieldMemory, } from './hopfield-memory.js';
 // R6: Cold-Tier GNN Training
-export { ColdTierTrainer, InMemoryGraph, FileBackedGraph, createColdTierTrainer, } from './cold-tier-trainer';
+export { ColdTierTrainer, InMemoryGraph, FileBackedGraph, createColdTierTrainer, } from './cold-tier-trainer.js';
 // ============================================================================
 // Phase 5: Scale & Optimization (ADR-087, Milestone 3)
 // ============================================================================
 // R8: PageRank Pattern Importance Solver
-export { PageRankSolver, createPageRankSolver, } from './solver-adapter';
+export { PageRankSolver, createPageRankSolver, } from './solver-adapter.js';
 // R9: Spectral Graph Sparsification
-export { SpectralSparsifier, createSpectralSparsifier, } from './spectral-sparsifier';
+export { SpectralSparsifier, createSpectralSparsifier, } from './spectral-sparsifier.js';
 // R10: Reservoir Replay with Coherence Gating
-export { ReservoirReplayBuffer, createReservoirReplayBuffer, } from './reservoir-replay';
+export { ReservoirReplayBuffer, createReservoirReplayBuffer, } from './reservoir-replay.js';
 // ============================================================================
 // Phase 5: Advanced Learning (ADR-087, Milestone 4)
 // ============================================================================
 // R11: E-prop Online Learning
-export { EpropNetwork, createEpropNetwork, } from './eprop-learner';
+export { EpropNetwork, createEpropNetwork, } from './eprop-learner.js';
 // R12: Granger Causality for Test Failure Prediction
-export { GrangerAnalyzer, createGrangerAnalyzer, } from './temporal-causality';
+export { GrangerAnalyzer, createGrangerAnalyzer, } from './temporal-causality.js';
 // ============================================================================
 // Phase 5: Routing & Geometry (ADR-087, Milestone 5)
 // ============================================================================
 // R13: Cognitive Routing
-export { CognitiveRouter, MessagePredictor, OscillatoryRouter, createCognitiveRouter, } from './cognitive-routing';
+export { CognitiveRouter, MessagePredictor, OscillatoryRouter, createCognitiveRouter, } from './cognitive-routing.js';
 // R14: Hyperbolic HNSW
-export { HyperbolicHNSW, PoincareOperations, createHyperbolicHNSW, } from './hyperbolic-hnsw';
+export { HyperbolicHNSW, PoincareOperations, createHyperbolicHNSW, } from './hyperbolic-hnsw.js';
 // ============================================================================
 // Shared Memory Integration (Fleet Integration)
 // ============================================================================
-export { initializeSharedMemory, getSharedServerClient as getFleetSharedClient, setSharedServerClient, isSharedMemoryAvailable, getSharedMemoryStatus, getLastInitResult, shutdownSharedMemory, resetSharedMemoryState, integrateWithFleet, DEFAULT_SHARED_MEMORY_CONFIG, } from './shared-memory';
+export { initializeSharedMemory, getSharedServerClient as getFleetSharedClient, setSharedServerClient, isSharedMemoryAvailable, getSharedMemoryStatus, getLastInitResult, shutdownSharedMemory, resetSharedMemoryState, integrateWithFleet, DEFAULT_SHARED_MEMORY_CONFIG, } from './shared-memory.js';
 //# sourceMappingURL=index.js.map

package/dist/integrations/ruvector/page-rank-backends.d.ts

@@ -0,0 +1,41 @@
+export interface PatternGraph {
+    nodes: string[];
+    edges: Array<[number, number, number]>;
+}
+export interface SolverConfig {
+    dampingFactor: number;
+    tolerance: number;
+    maxIterations: number;
+}
+export interface NativePageRankResult {
+    scores: number[] | Float64Array;
+    converged: boolean;
+    iterations: number;
+    residual: number;
+}
+export interface NativePageRankSolver {
+    pagerank(input: {
+        values: number[];
+        colIndices: number[];
+        rowPtrs: number[];
+        numNodes: number;
+        damping: number;
+        tolerance: number;
+        maxIterations: number;
+    }): Promise<NativePageRankResult>;
+}
+export interface NativeSolverModule {
+    NapiSolver: new () => NativePageRankSolver;
+}
+export type AsyncPageRankRunner = (graph: PatternGraph, config: SolverConfig, timeoutMs?: number) => Promise<Float64Array>;
+/** Standard weighted PageRank with uniform dangling-node redistribution. */
+export declare function computeTypeScriptPageRank(graph: PatternGraph, config: SolverConfig): Float64Array;
+export declare function edgeListToCsr(graph: PatternGraph): {
+    values: number[];
+    colIndices: number[];
+    rowPtrs: number[];
+};
+export declare function loadNativeSolverModule(): NativeSolverModule | null;
+export declare function runNativePageRank(module: NativeSolverModule, graph: PatternGraph, config: SolverConfig): Promise<Float64Array>;
+export declare function runPageRankWorker(graph: PatternGraph, config: SolverConfig, timeoutMs?: number): Promise<Float64Array>;
+//# sourceMappingURL=page-rank-backends.d.ts.map

package/dist/integrations/ruvector/page-rank-backends.js

@@ -0,0 +1,154 @@
+import { createRequire } from 'node:module';
+import { Worker } from 'node:worker_threads';
+/** Standard weighted PageRank with uniform dangling-node redistribution. */
+export function computeTypeScriptPageRank(graph, config) {
+    const n = graph.nodes.length;
+    if (n === 0)
+        return new Float64Array();
+    const { dampingFactor: d, tolerance, maxIterations } = config;
+    const weightedOutDegree = new Float64Array(n);
+    const inEdges = new Array(n);
+    for (let i = 0; i < n; i++)
+        inEdges[i] = [];
+    for (const [from, to, weight] of graph.edges) {
+        weightedOutDegree[from] += weight;
+        inEdges[to].push([from, weight]);
+    }
+    const danglingNodes = [];
+    for (let i = 0; i < n; i++) {
+        if (weightedOutDegree[i] === 0)
+            danglingNodes.push(i);
+    }
+    let scores = new Float64Array(n);
+    scores.fill(1 / n);
+    const base = (1 - d) / n;
+    for (let iter = 0; iter < maxIterations; iter++) {
+        let danglingSum = 0;
+        for (const index of danglingNodes)
+            danglingSum += scores[index];
+        const danglingContribution = d * danglingSum / n;
+        const next = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            let incoming = 0;
+            for (const [from, weight] of inEdges[i]) {
+                incoming += scores[from] * weight / weightedOutDegree[from];
+            }
+            next[i] = base + d * incoming + danglingContribution;
+        }
+        let maxDelta = 0;
+        for (let i = 0; i < n; i++) {
+            maxDelta = Math.max(maxDelta, Math.abs(next[i] - scores[i]));
+        }
+        scores = next;
+        if (maxDelta < tolerance)
+            break;
+    }
+    return scores;
+}
+export function edgeListToCsr(graph) {
+    const rows = Array.from({ length: graph.nodes.length }, () => []);
+    for (const [from, to, weight] of graph.edges)
+        rows[from].push([to, weight]);
+    const values = [];
+    const colIndices = [];
+    const rowPtrs = [0];
+    for (const row of rows) {
+        row.sort((left, right) => left[0] - right[0]);
+        for (const [column, value] of row) {
+            colIndices.push(column);
+            values.push(value);
+        }
+        rowPtrs.push(values.length);
+    }
+    return { values, colIndices, rowPtrs };
+}
+export function loadNativeSolverModule() {
+    try {
+        const req = createRequire(import.meta.url);
+        const candidate = req('@ruvector/solver');
+        return typeof candidate.NapiSolver === 'function'
+            ? candidate
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function runNativePageRank(module, graph, config) {
+    const csr = edgeListToCsr(graph);
+    const result = await new module.NapiSolver().pagerank({
+        ...csr,
+        numNodes: graph.nodes.length,
+        damping: config.dampingFactor,
+        tolerance: config.tolerance,
+        maxIterations: config.maxIterations,
+    });
+    if (!result.converged)
+        throw new Error('Native PageRank did not converge');
+    return validatePageRankScores(result.scores, graph.nodes.length);
+}
+export function runPageRankWorker(graph, config, timeoutMs = 30_000) {
+    const workerSource = `
+    const { parentPort, workerData } = require('node:worker_threads');
+    const compute = ${computeTypeScriptPageRank.toString()};
+    try {
+      const graph = {
+        nodes: new Array(workerData.nodeCount),
+        edges: workerData.edges,
+      };
+      const scores = compute(graph, workerData.config);
+      parentPort.postMessage(scores, [scores.buffer]);
+    } catch (error) {
+      throw error;
+    }
+  `;
+    return new Promise((resolve, reject) => {
+        const worker = new Worker(workerSource, {
+            eval: true,
+            workerData: {
+                nodeCount: graph.nodes.length,
+                edges: graph.edges,
+                config,
+            },
+        });
+        const timeout = setTimeout(() => {
+            void worker.terminate();
+            reject(new Error(`PageRank worker timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        worker.once('message', (scores) => {
+            clearTimeout(timeout);
+            resolve(validatePageRankScores(scores, graph.nodes.length));
+        });
+        worker.once('error', (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        worker.once('exit', (code) => {
+            if (code !== 0) {
+                clearTimeout(timeout);
+                reject(new Error(`PageRank worker exited with code ${code}`));
+            }
+        });
+    });
+}
+function validatePageRankScores(input, expectedLength) {
+    const scores = input instanceof Float64Array ? input : Float64Array.from(input);
+    if (scores.length !== expectedLength) {
+        throw new Error(`PageRank returned ${scores.length} scores for ${expectedLength} nodes`);
+    }
+    let total = 0;
+    for (const score of scores) {
+        if (!Number.isFinite(score) || score < 0) {
+            throw new Error('PageRank returned an invalid score');
+        }
+        total += score;
+    }
+    if (!(total > 0))
+        throw new Error('PageRank returned a zero score total');
+    if (Math.abs(total - 1) > 1e-12) {
+        for (let i = 0; i < scores.length; i++)
+            scores[i] /= total;
+    }
+    return scores;
+}
+//# sourceMappingURL=page-rank-backends.js.map

package/dist/integrations/ruvector/persistent-q-router.js

@@ -24,8 +24,8 @@
  * await router.provideFeedback(task.id, { success: true, durationMs: 100, quality: 0.9 });
  * ```
  */
-import { createQLearningRouterSync } from './q-learning-router';
-import { createQValueStore } from '../rl-suite/persistence/q-value-store';
+import { createQLearningRouterSync } from './q-learning-router.js';
+import { createQValueStore } from '../rl-suite/persistence/q-value-store.js';
 import { toErrorMessage } from '../../shared/error-utils.js';
 // ============================================================================
 // Module Constants

package/dist/integrations/ruvector/q-learning-router.js

@@ -6,7 +6,7 @@
  */
 import { toErrorMessage } from '../../shared/error-utils.js';
 import { secureRandom, secureRandomInt } from '../../shared/utils/crypto-random.js';
-import { FallbackQLearningRouter } from './fallback';
+import { FallbackQLearningRouter } from './fallback.js';
 import { getUnifiedMemory } from '../../kernel/unified-memory.js';
 const DEFAULT_PARAMS = {
     learningRate: 0.1,

package/dist/integrations/ruvector/solver-adapter.d.ts

@@ -4,8 +4,8 @@
  * Provides graph-based importance scoring for QE patterns using PageRank.
  *
  * Two execution paths:
- * - **Native** (@ruvector/solver-node): O(log n) sublinear via Neumann series.
- *   Requires the optional NAPI dependency to be installed.
+ * - **Async**: optional @ruvector/solver NAPI backend, then worker-thread
+ *   TypeScript fallback for large graphs.
  * - **TypeScript fallback**: Standard power iteration, O(n * m * iterations).
  *   Always available, correct results, linear-time.
  *
@@ -20,45 +20,43 @@
  *
  * @module integrations/ruvector/solver-adapter
  */
+import { type AsyncPageRankRunner, type NativeSolverModule, type PatternGraph, type SolverConfig } from './page-rank-backends.js';
+export type { PatternGraph, SolverConfig } from './page-rank-backends.js';
 /**
  * A directed graph of pattern relationships for importance scoring.
  *
  * Nodes represent pattern IDs; edges encode directed relationships
  * (e.g., "pattern A depends on pattern B") with numeric weights.
  */
-export interface PatternGraph {
-    /** Node IDs (pattern IDs) */
-    nodes: string[];
-    /** Directed edges: [fromIndex, toIndex, weight] */
-    edges: Array<[number, number, number]>;
-}
 /** Result of importance scoring for a single pattern */
 export interface ImportanceScore {
     patternId: string;
     score: number;
     rank: number;
 }
-/** Configuration for the solver */
-export interface SolverConfig {
-    /** Damping factor for PageRank (default: 0.85) */
-    dampingFactor: number;
-    /** Convergence tolerance (default: 1e-6) */
-    tolerance: number;
-    /** Maximum iterations for power iteration fallback (default: 100) */
-    maxIterations: number;
+export interface PageRankRuntimeOptions {
+    /** Minimum nodes + edges before using a worker (default: 50,000). */
+    workerThreshold: number;
+    /** Worker timeout before synchronous fallback (default: 30 seconds). */
+    workerTimeoutMs: number;
+    /** Dependency-injection seam for tests and alternative worker runners. */
+    workerRunner: AsyncPageRankRunner;
+    /** Override native discovery; null explicitly disables the native backend. */
+    nativeModule?: NativeSolverModule | null;
 }
 /**
  * Computes importance scores for pattern graphs using PageRank.
  *
- * Prefers the native @ruvector/solver-node NAPI bindings when available
- * (O(log n) via Neumann series). Falls back to a TypeScript power-iteration
- * implementation (O(n * m * iterations)) when the native module is absent.
+ * The synchronous API uses the deterministic TypeScript implementation.
+ * The async API prefers @ruvector/solver and offloads large fallback graphs.
  */
 export declare class PageRankSolver {
     private readonly config;
-    constructor(config?: Partial<SolverConfig>);
+    private readonly runtime;
+    private readonly nativeModule;
+    constructor(config?: Partial<SolverConfig>, runtime?: Partial<PageRankRuntimeOptions>);
     /**
-     * Check whether the native @ruvector/solver-node module is available.
+     * Check whether the native @ruvector/solver module is available.
      */
     isNativeAvailable(): boolean;
     /**
@@ -68,6 +66,11 @@ export declare class PageRankSolver {
      * @returns Map from node ID to its importance score (scores sum to ~1.0)
      */
     computeImportance(graph: PatternGraph): Map<string, number>;
+    /**
+     * Compute PageRank without blocking the event loop for large graphs.
+     * Native and worker failures fall back to the verified synchronous backend.
+     */
+    computeImportanceAsync(graph: PatternGraph): Promise<Map<string, number>>;
     /**
      * Rank all patterns in the graph by importance, highest first.
      *
@@ -75,13 +78,7 @@ export declare class PageRankSolver {
      * @returns Array of ImportanceScore sorted by score descending
      */
     rankPatterns(graph: PatternGraph): ImportanceScore[];
-    /**
-     * Delegate PageRank computation to the native @ruvector/solver-node module.
-     *
-     * The native API is expected to accept the graph in a compatible format
-     * and return a Float64Array of scores indexed by node position.
-     */
-    private computeNative;
+    private copyScoresToResult;
 }
 /**
  * Create a PageRankSolver instance with the given configuration.
@@ -89,5 +86,5 @@ export declare class PageRankSolver {
  * @param config - Partial solver configuration (defaults applied)
  * @returns A configured PageRankSolver
  */
-export declare function createPageRankSolver(config?: Partial<SolverConfig>): PageRankSolver;
+export declare function createPageRankSolver(config?: Partial<SolverConfig>, runtime?: Partial<PageRankRuntimeOptions>): PageRankSolver;
 //# sourceMappingURL=solver-adapter.d.ts.map