agentic-qe 3.8.10 → 3.8.12

package/dist/integrations/ruvector/cold-tier-trainer.d.ts

@@ -0,0 +1,103 @@
+/**
+ * R6: Cold-Tier GNN Training
+ *
+ * LRU-cached mini-batch GNN trainer for graphs exceeding a configurable
+ * memory budget (hotsetSize). Uses an LRU eviction cache to limit the
+ * number of node features held in memory simultaneously.
+ *
+ * When the graph fits within hotsetSize, trains fully in-memory (fast path).
+ * When the graph exceeds hotsetSize, streams nodes through the LRU cache
+ * with eviction, producing embeddings only for the hot-set nodes.
+ *
+ * TypeScript implementation. Future: NAPI upgrade via @ruvector/gnn cold_tier
+ * for true block-aligned disk I/O with mmap-backed node storage.
+ *
+ * @module integrations/ruvector/cold-tier-trainer
+ */
+export interface ColdTierConfig {
+    /** Maximum nodes kept in memory (hot set). Default: 10000 */
+    hotsetSize: number;
+    /** Number of training epochs. Default: 10 */
+    epochs: number;
+    /** Learning rate. Default: 0.01 */
+    learningRate: number;
+    /** Hidden dimension for GNN layers. Default: 64 */
+    hiddenDim: number;
+}
+export interface ColdTierGraph {
+    nodeCount: number;
+    featureDim: number;
+    getNode(id: number): Float32Array | null;
+    getNeighbors(id: number): number[];
+    nodeIds(): Iterable<number>;
+}
+export interface TrainingResult {
+    loss: number;
+    lossHistory: number[];
+    embeddings: Map<number, Float32Array>;
+    peakMemoryNodes: number;
+    usedInMemoryMode: boolean;
+}
+export interface CacheStats {
+    hits: number;
+    misses: number;
+    evictions: number;
+    currentSize: number;
+}
+/** Simple in-memory graph for testing and small graphs. */
+export declare class InMemoryGraph implements ColdTierGraph {
+    private features;
+    private adjacency;
+    constructor(features: Map<number, Float32Array>, adjacency: Map<number, number[]>);
+    get nodeCount(): number;
+    get featureDim(): number;
+    getNode(id: number): Float32Array | null;
+    getNeighbors(id: number): number[];
+    nodeIds(): Iterable<number>;
+}
+/**
+ * File-backed graph for larger-than-RAM training.
+ * Writes node features to a temp file in block-aligned format,
+ * reads them back lazily via getNode().
+ */
+export declare class FileBackedGraph implements ColdTierGraph {
+    private readonly featureFile;
+    private readonly nodeOffsets;
+    private readonly adjacency;
+    private readonly _nodeCount;
+    private readonly _featureDim;
+    private readonly bytesPerNode;
+    constructor(features: Map<number, Float32Array>, adjacency: Map<number, number[]>, storagePath?: string);
+    get nodeCount(): number;
+    get featureDim(): number;
+    getNode(id: number): Float32Array | null;
+    getNeighbors(id: number): number[];
+    nodeIds(): Iterable<number>;
+    /** Clean up temp file */
+    dispose(): void;
+}
+/** LRU-cached GNN trainer with mean-aggregation message passing. */
+export declare class ColdTierTrainer {
+    private readonly config;
+    private cache;
+    private weights;
+    private bias;
+    constructor(config?: Partial<ColdTierConfig>);
+    /** Train a GNN on the given graph. Throws if useColdTierGNN flag is off. */
+    train(graph: ColdTierGraph): TrainingResult;
+    getCacheStats(): CacheStats;
+    reset(): void;
+    /** Mean-aggregate self + neighbor features into a pre-allocated buffer. */
+    private aggregate;
+    /** Forward pass: aggregated * W + bias with ReLU. */
+    private linearRelu;
+    private trainNode;
+    /** Forward-only pass for embedding extraction. */
+    private forward;
+    private fetchNode;
+    private ensureCached;
+    private shuffle;
+}
+/** Create a ColdTierTrainer with the given configuration. */
+export declare function createColdTierTrainer(config?: Partial<ColdTierConfig>): ColdTierTrainer;
+//# sourceMappingURL=cold-tier-trainer.d.ts.map

package/dist/integrations/ruvector/cold-tier-trainer.js

@@ -0,0 +1,377 @@
+/**
+ * R6: Cold-Tier GNN Training
+ *
+ * LRU-cached mini-batch GNN trainer for graphs exceeding a configurable
+ * memory budget (hotsetSize). Uses an LRU eviction cache to limit the
+ * number of node features held in memory simultaneously.
+ *
+ * When the graph fits within hotsetSize, trains fully in-memory (fast path).
+ * When the graph exceeds hotsetSize, streams nodes through the LRU cache
+ * with eviction, producing embeddings only for the hot-set nodes.
+ *
+ * TypeScript implementation. Future: NAPI upgrade via @ruvector/gnn cold_tier
+ * for true block-aligned disk I/O with mmap-backed node storage.
+ *
+ * @module integrations/ruvector/cold-tier-trainer
+ */
+import { getRuVectorFeatureFlags } from './feature-flags.js';
+import { Xorshift128 } from '../../shared/utils/xorshift128.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_CONFIG = {
+    hotsetSize: 10000,
+    epochs: 10,
+    learningRate: 0.01,
+    hiddenDim: 64,
+};
+// ============================================================================
+// Internal: LRU Cache
+// ============================================================================
+class LruNodeCache {
+    capacity;
+    entries = new Map();
+    accessCounter = 0;
+    _hits = 0;
+    _misses = 0;
+    _evictions = 0;
+    _peakSize = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    get(id) {
+        const entry = this.entries.get(id);
+        if (entry) {
+            this._hits++;
+            entry.lastAccess = ++this.accessCounter;
+            return entry.features;
+        }
+        this._misses++;
+        return null;
+    }
+    put(id, features) {
+        const existing = this.entries.get(id);
+        if (existing) {
+            existing.features = features;
+            existing.lastAccess = ++this.accessCounter;
+            return;
+        }
+        if (this.entries.size >= this.capacity)
+            this.evictLru();
+        this.entries.set(id, { features, lastAccess: ++this.accessCounter });
+        if (this.entries.size > this._peakSize)
+            this._peakSize = this.entries.size;
+    }
+    get peakSize() { return this._peakSize; }
+    get stats() {
+        return { hits: this._hits, misses: this._misses, evictions: this._evictions, currentSize: this.entries.size };
+    }
+    cachedIds() {
+        return Array.from(this.entries.keys());
+    }
+    clear() {
+        this.entries.clear();
+        this.accessCounter = 0;
+        this._hits = this._misses = this._evictions = this._peakSize = 0;
+    }
+    evictLru() {
+        let oldestAccess = Infinity;
+        let oldestId = -1;
+        for (const [id, entry] of this.entries) {
+            if (entry.lastAccess < oldestAccess) {
+                oldestAccess = entry.lastAccess;
+                oldestId = id;
+            }
+        }
+        if (oldestId >= 0) {
+            this.entries.delete(oldestId);
+            this._evictions++;
+        }
+    }
+}
+// ============================================================================
+// InMemoryGraph
+// ============================================================================
+/** Simple in-memory graph for testing and small graphs. */
+export class InMemoryGraph {
+    features;
+    adjacency;
+    constructor(features, adjacency) {
+        this.features = features;
+        this.adjacency = adjacency;
+    }
+    get nodeCount() { return this.features.size; }
+    get featureDim() {
+        const first = this.features.values().next();
+        return first.done ? 0 : first.value.length;
+    }
+    getNode(id) { return this.features.get(id) ?? null; }
+    getNeighbors(id) { return this.adjacency.get(id) ?? []; }
+    *nodeIds() { yield* this.features.keys(); }
+}
+// ============================================================================
+// FileBackedGraph
+// ============================================================================
+/**
+ * File-backed graph for larger-than-RAM training.
+ * Writes node features to a temp file in block-aligned format,
+ * reads them back lazily via getNode().
+ */
+export class FileBackedGraph {
+    featureFile;
+    nodeOffsets;
+    adjacency;
+    _nodeCount;
+    _featureDim;
+    bytesPerNode;
+    constructor(features, adjacency, storagePath) {
+        const fs = require('fs');
+        const os = require('os');
+        const path = require('path');
+        this._nodeCount = features.size;
+        this._featureDim = features.values().next().value?.length ?? 0;
+        this.bytesPerNode = this._featureDim * 4; // Float32 = 4 bytes
+        this.adjacency = adjacency;
+        this.nodeOffsets = new Map();
+        // Write features to a temp file with sequential block-aligned layout
+        this.featureFile = storagePath ?? path.join(os.tmpdir(), `coldtier-${Date.now()}-${Math.random().toString(36).slice(2)}.bin`);
+        const buffer = Buffer.alloc(this._nodeCount * this.bytesPerNode);
+        let offset = 0;
+        for (const [id, feat] of features) {
+            this.nodeOffsets.set(id, offset);
+            for (let i = 0; i < feat.length; i++) {
+                buffer.writeFloatLE(feat[i], offset + i * 4);
+            }
+            offset += this.bytesPerNode;
+        }
+        fs.writeFileSync(this.featureFile, buffer);
+    }
+    get nodeCount() { return this._nodeCount; }
+    get featureDim() { return this._featureDim; }
+    getNode(id) {
+        const offset = this.nodeOffsets.get(id);
+        if (offset === undefined)
+            return null;
+        const fs = require('fs');
+        const buf = Buffer.alloc(this.bytesPerNode);
+        const fd = fs.openSync(this.featureFile, 'r');
+        fs.readSync(fd, buf, 0, this.bytesPerNode, offset);
+        fs.closeSync(fd);
+        const result = new Float32Array(this._featureDim);
+        for (let i = 0; i < this._featureDim; i++) {
+            result[i] = buf.readFloatLE(i * 4);
+        }
+        return result;
+    }
+    getNeighbors(id) { return this.adjacency.get(id) ?? []; }
+    *nodeIds() { yield* this.nodeOffsets.keys(); }
+    /** Clean up temp file */
+    dispose() {
+        try {
+            const fs = require('fs');
+            if (fs.existsSync(this.featureFile))
+                fs.unlinkSync(this.featureFile);
+        }
+        catch { /* ignore cleanup failures */ }
+    }
+}
+// ============================================================================
+// ColdTierTrainer
+// ============================================================================
+/** LRU-cached GNN trainer with mean-aggregation message passing. */
+export class ColdTierTrainer {
+    config;
+    cache;
+    weights = null;
+    bias = null;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        if (this.config.hotsetSize <= 0) {
+            throw new Error(`hotsetSize must be positive, got ${this.config.hotsetSize}`);
+        }
+        this.cache = new LruNodeCache(this.config.hotsetSize);
+    }
+    // --------------------------------------------------------------------------
+    // Public API
+    // --------------------------------------------------------------------------
+    /** Train a GNN on the given graph. Throws if useColdTierGNN flag is off. */
+    train(graph) {
+        if (!getRuVectorFeatureFlags().useColdTierGNN) {
+            throw new Error('Cold-Tier GNN training is disabled (useColdTierGNN = false)');
+        }
+        if (graph.nodeCount === 0) {
+            return { loss: 0, lossHistory: [], embeddings: new Map(), peakMemoryNodes: 0, usedInMemoryMode: true };
+        }
+        this.cache.clear();
+        const inMemory = graph.nodeCount <= this.config.hotsetSize;
+        const nodeIds = [...graph.nodeIds()];
+        const rng = new Xorshift128(42);
+        // Xavier/Glorot weight init
+        const { featureDim } = graph;
+        const { hiddenDim } = this.config;
+        const scale = Math.sqrt(2.0 / (featureDim + hiddenDim));
+        this.weights = new Float32Array(featureDim * hiddenDim);
+        for (let i = 0; i < this.weights.length; i++)
+            this.weights[i] = rng.nextGaussian() * scale;
+        this.bias = new Float32Array(hiddenDim);
+        // Preload all nodes for in-memory mode
+        if (inMemory) {
+            for (const id of nodeIds) {
+                const f = graph.getNode(id);
+                if (f)
+                    this.cache.put(id, f);
+            }
+        }
+        const lossHistory = [];
+        for (let epoch = 0; epoch < this.config.epochs; epoch++) {
+            this.shuffle(nodeIds, rng);
+            let epochLoss = 0;
+            let count = 0;
+            for (const id of nodeIds) {
+                if (!inMemory)
+                    this.ensureCached(id, graph);
+                epochLoss += this.trainNode(id, graph);
+                count++;
+            }
+            lossHistory.push(count > 0 ? epochLoss / count : 0);
+        }
+        // Collect embeddings
+        const embIds = inMemory ? nodeIds : this.cache.cachedIds();
+        const embeddings = new Map();
+        for (const id of embIds) {
+            const emb = this.forward(id, graph);
+            if (emb)
+                embeddings.set(id, emb);
+        }
+        return {
+            loss: lossHistory.length > 0 ? lossHistory[lossHistory.length - 1] : 0,
+            lossHistory,
+            embeddings,
+            peakMemoryNodes: this.cache.peakSize,
+            usedInMemoryMode: inMemory,
+        };
+    }
+    getCacheStats() { return this.cache.stats; }
+    reset() {
+        this.cache.clear();
+        this.weights = null;
+        this.bias = null;
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Aggregation (shared by training and forward)
+    // --------------------------------------------------------------------------
+    /** Mean-aggregate self + neighbor features into a pre-allocated buffer. */
+    aggregate(id, graph, out) {
+        const self = this.fetchNode(id, graph);
+        if (!self)
+            return null;
+        const dim = graph.featureDim;
+        let count = 1;
+        for (let d = 0; d < dim; d++)
+            out[d] = self[d];
+        for (const nid of graph.getNeighbors(id)) {
+            const nf = this.fetchNode(nid, graph);
+            if (nf) {
+                for (let d = 0; d < dim; d++)
+                    out[d] += nf[d];
+                count++;
+            }
+        }
+        for (let d = 0; d < dim; d++)
+            out[d] /= count;
+        return self;
+    }
+    /** Forward pass: aggregated * W + bias with ReLU. */
+    linearRelu(agg, featureDim, hiddenDim) {
+        const h = new Float32Array(hiddenDim);
+        for (let j = 0; j < hiddenDim; j++) {
+            let s = this.bias[j];
+            for (let i = 0; i < featureDim; i++)
+                s += agg[i] * this.weights[i * hiddenDim + j];
+            h[j] = Math.max(0, s);
+        }
+        return h;
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Training step
+    // --------------------------------------------------------------------------
+    trainNode(id, graph) {
+        if (!this.weights || !this.bias)
+            return 0;
+        const { featureDim } = graph;
+        const { hiddenDim, learningRate: lr } = this.config;
+        const agg = new Float32Array(featureDim);
+        const self = this.aggregate(id, graph, agg);
+        if (!self)
+            return 0;
+        const hidden = this.linearRelu(agg, featureDim, hiddenDim);
+        // MSE loss: hidden vs truncated input features
+        const cmpDim = Math.min(hiddenDim, featureDim);
+        let loss = 0;
+        for (let d = 0; d < cmpDim; d++) {
+            const diff = hidden[d] - self[d];
+            loss += diff * diff;
+        }
+        loss /= cmpDim;
+        // SGD weight update
+        for (let j = 0; j < cmpDim; j++) {
+            const grad = (2 * (hidden[j] - self[j]) / cmpDim) * (hidden[j] > 0 ? 1 : 0);
+            this.bias[j] -= lr * grad;
+            for (let i = 0; i < featureDim; i++) {
+                this.weights[i * hiddenDim + j] -= lr * grad * agg[i];
+            }
+        }
+        return loss;
+    }
+    /** Forward-only pass for embedding extraction. */
+    forward(id, graph) {
+        if (!this.weights || !this.bias)
+            return null;
+        const agg = new Float32Array(graph.featureDim);
+        if (!this.aggregate(id, graph, agg))
+            return null;
+        return this.linearRelu(agg, graph.featureDim, this.config.hiddenDim);
+    }
+    // --------------------------------------------------------------------------
+    // Internal: Cache helpers
+    // --------------------------------------------------------------------------
+    fetchNode(id, graph) {
+        const cached = this.cache.get(id);
+        if (cached)
+            return cached;
+        const features = graph.getNode(id);
+        if (features)
+            this.cache.put(id, features);
+        return features;
+    }
+    ensureCached(id, graph) {
+        if (this.cache.get(id))
+            return;
+        const f = graph.getNode(id);
+        if (f)
+            this.cache.put(id, f);
+    }
+    shuffle(arr, rng) {
+        for (let i = arr.length - 1; i > 0; i--) {
+            // Use rejection sampling to avoid modulo bias
+            const range = i + 1;
+            const limit = 0x100000000 - (0x100000000 % range);
+            let r;
+            do {
+                r = rng.next();
+            } while (r >= limit);
+            const j = r % range;
+            const tmp = arr[i];
+            arr[i] = arr[j];
+            arr[j] = tmp;
+        }
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+/** Create a ColdTierTrainer with the given configuration. */
+export function createColdTierTrainer(config) {
+    return new ColdTierTrainer(config);
+}
+//# sourceMappingURL=cold-tier-trainer.js.map

package/dist/integrations/ruvector/cusum-detector.d.ts

@@ -0,0 +1,70 @@
+/**
+ * CUSUM Drift Detector (R2, Phase 5)
+ *
+ * Two-sided Cumulative Sum (CUSUM) detector for monitoring coherence
+ * gate energy drift. Each gate type maintains independent state.
+ *
+ * Algorithm:
+ *   S+(n) = max(0, S+(n-1) + (x_n - mu - slack))
+ *   S-(n) = max(0, S-(n-1) + (-x_n + mu - slack))
+ *   Drift detected when S+ > threshold OR S- > threshold
+ *
+ * mu is the running mean of the first N samples (warmup period).
+ *
+ * @module integrations/ruvector/cusum-detector
+ * @see ADR-087-ruvector-advanced-capabilities.md
+ */
+/** Configuration for the CUSUM detector */
+export interface CusumConfig {
+    /** Detection threshold (default: 5.0) */
+    threshold: number;
+    /** Allowable slack/drift (default: 0.5) */
+    slack: number;
+    /** Reset cumulative sum after alarm (default: true) */
+    resetOnAlarm: boolean;
+    /** Number of samples for warmup period to estimate mu (default: 20) */
+    warmupSamples: number;
+}
+/** Result of a CUSUM update */
+export interface CusumResult {
+    /** Whether drift was detected */
+    driftDetected: boolean;
+    /** Current cumulative sum (max of positive and negative) */
+    cumulativeSum: number;
+    /** Direction of detected drift */
+    direction: 'positive' | 'negative' | 'none';
+    /** Number of samples since last reset */
+    samplesSinceReset: number;
+}
+/** Gate types that can be independently monitored */
+export type GateType = 'retrieve' | 'write' | 'learn' | 'act';
+/**
+ * Two-sided CUSUM detector for drift monitoring.
+ *
+ * Tracks both positive and negative cumulative sums per gate type.
+ * During the warmup period, samples are collected to estimate the
+ * running mean (mu). After warmup, deviations from mu are accumulated
+ * and compared against the threshold.
+ */
+export declare class CusumDetector {
+    private readonly config;
+    private readonly states;
+    constructor(config?: Partial<CusumConfig>);
+    /**
+     * Update the CUSUM state for a gate type with a new sample value.
+     *
+     * During warmup, collects samples to estimate mu.
+     * After warmup, applies the two-sided CUSUM algorithm.
+     */
+    update(gateType: GateType, value: number): CusumResult;
+    /**
+     * Reset the CUSUM state for a specific gate type, or all gates.
+     */
+    reset(gateType?: GateType): void;
+    /**
+     * Get the current CUSUM state for a gate type without updating.
+     */
+    getState(gateType: GateType): CusumResult;
+    private getOrCreateState;
+}
+//# sourceMappingURL=cusum-detector.d.ts.map

package/dist/integrations/ruvector/cusum-detector.js

@@ -0,0 +1,142 @@
+/**
+ * CUSUM Drift Detector (R2, Phase 5)
+ *
+ * Two-sided Cumulative Sum (CUSUM) detector for monitoring coherence
+ * gate energy drift. Each gate type maintains independent state.
+ *
+ * Algorithm:
+ *   S+(n) = max(0, S+(n-1) + (x_n - mu - slack))
+ *   S-(n) = max(0, S-(n-1) + (-x_n + mu - slack))
+ *   Drift detected when S+ > threshold OR S- > threshold
+ *
+ * mu is the running mean of the first N samples (warmup period).
+ *
+ * @module integrations/ruvector/cusum-detector
+ * @see ADR-087-ruvector-advanced-capabilities.md
+ */
+const DEFAULT_CONFIG = {
+    threshold: 5.0,
+    slack: 0.5,
+    resetOnAlarm: true,
+    warmupSamples: 20,
+};
+/**
+ * Two-sided CUSUM detector for drift monitoring.
+ *
+ * Tracks both positive and negative cumulative sums per gate type.
+ * During the warmup period, samples are collected to estimate the
+ * running mean (mu). After warmup, deviations from mu are accumulated
+ * and compared against the threshold.
+ */
+export class CusumDetector {
+    config;
+    states = new Map();
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Update the CUSUM state for a gate type with a new sample value.
+     *
+     * During warmup, collects samples to estimate mu.
+     * After warmup, applies the two-sided CUSUM algorithm.
+     */
+    update(gateType, value) {
+        const state = this.getOrCreateState(gateType);
+        state.samplesSinceReset++;
+        // Warmup phase: collect samples to estimate mu
+        if (state.mu === null) {
+            state.warmupSum += value;
+            state.warmupCount++;
+            if (state.warmupCount >= this.config.warmupSamples) {
+                state.mu = state.warmupSum / state.warmupCount;
+            }
+            return {
+                driftDetected: false,
+                cumulativeSum: 0,
+                direction: 'none',
+                samplesSinceReset: state.samplesSinceReset,
+            };
+        }
+        // Two-sided CUSUM update
+        state.sPlus = Math.max(0, state.sPlus + (value - state.mu - this.config.slack));
+        state.sMinus = Math.max(0, state.sMinus + (-value + state.mu - this.config.slack));
+        const cumulativeSum = Math.max(state.sPlus, state.sMinus);
+        let driftDetected = false;
+        let direction = 'none';
+        if (state.sPlus > this.config.threshold) {
+            driftDetected = true;
+            direction = 'positive';
+        }
+        else if (state.sMinus > this.config.threshold) {
+            driftDetected = true;
+            direction = 'negative';
+        }
+        const result = {
+            driftDetected,
+            cumulativeSum,
+            direction,
+            samplesSinceReset: state.samplesSinceReset,
+        };
+        if (driftDetected && this.config.resetOnAlarm) {
+            state.sPlus = 0;
+            state.sMinus = 0;
+            state.samplesSinceReset = 0;
+        }
+        return result;
+    }
+    /**
+     * Reset the CUSUM state for a specific gate type, or all gates.
+     */
+    reset(gateType) {
+        if (gateType) {
+            this.states.delete(gateType);
+        }
+        else {
+            this.states.clear();
+        }
+    }
+    /**
+     * Get the current CUSUM state for a gate type without updating.
+     */
+    getState(gateType) {
+        const state = this.states.get(gateType);
+        if (!state) {
+            return {
+                driftDetected: false,
+                cumulativeSum: 0,
+                direction: 'none',
+                samplesSinceReset: 0,
+            };
+        }
+        const cumulativeSum = Math.max(state.sPlus, state.sMinus);
+        let direction = 'none';
+        if (state.sPlus > this.config.threshold) {
+            direction = 'positive';
+        }
+        else if (state.sMinus > this.config.threshold) {
+            direction = 'negative';
+        }
+        return {
+            driftDetected: state.sPlus > this.config.threshold || state.sMinus > this.config.threshold,
+            cumulativeSum,
+            direction,
+            samplesSinceReset: state.samplesSinceReset,
+        };
+    }
+    getOrCreateState(gateType) {
+        let state = this.states.get(gateType);
+        if (!state) {
+            state = {
+                sPlus: 0,
+                sMinus: 0,
+                samplesSinceReset: 0,
+                warmupSum: 0,
+                warmupCount: 0,
+                mu: null,
+            };
+            this.states.set(gateType, state);
+        }
+        return state;
+    }
+}
+//# sourceMappingURL=cusum-detector.js.map