agentic-qe 3.8.14 → 3.9.1

package/dist/persistence/rvf-consistency-validator.d.ts

@@ -0,0 +1,85 @@
+/**
+ * RVF Consistency Validator (ADR-072)
+ *
+ * Periodically samples reads from both SQLite and RVF engines, compares
+ * results, and tracks divergence rate over a rolling window. Monitors
+ * RVF deadSpaceRatio and triggers compaction when needed.
+ *
+ * Used by RvfStageGate to make go/no-go decisions for stage promotion.
+ *
+ * @module persistence/rvf-consistency-validator
+ */
+import type { RvfStore } from '../integrations/ruvector/rvf-dual-writer.js';
+export interface ConsistencyCheckResult {
+    /** Timestamp of the check */
+    timestamp: number;
+    /** Number of samples compared */
+    samplesChecked: number;
+    /** Number of divergences found */
+    divergences: number;
+    /** Divergence rate (0-1) */
+    divergenceRate: number;
+    /** Details of any divergences */
+    details: DivergenceDetail[];
+    /** RVF dead space ratio (if available) */
+    deadSpaceRatio: number | null;
+    /** Whether compaction was triggered */
+    compactionTriggered: boolean;
+}
+export interface DivergenceDetail {
+    patternId: string;
+    issue: 'missing-in-rvf' | 'missing-in-sqlite' | 'score-mismatch';
+    sqliteScore?: number;
+    rvfScore?: number;
+}
+export interface ValidatorConfig {
+    /** Number of random samples per check (default: 50) */
+    sampleSize: number;
+    /** Rolling window duration in ms (default: 7 days) */
+    windowDurationMs: number;
+    /** Dead space ratio threshold to trigger compaction (default: 0.3) */
+    compactionThreshold: number;
+    /** Score difference threshold to count as divergence (default: 0.05) */
+    scoreTolerance: number;
+}
+interface SqliteDb {
+    prepare(sql: string): {
+        run(...params: unknown[]): {
+            changes: number;
+        };
+        get(...params: unknown[]): unknown;
+        all(...params: unknown[]): unknown[];
+    };
+}
+export declare class RvfConsistencyValidator {
+    private readonly config;
+    private db;
+    private rvfStore;
+    private history;
+    constructor(config?: Partial<ValidatorConfig>);
+    setSqliteDb(db: SqliteDb): void;
+    setRvfStore(store: RvfStore): void;
+    /**
+     * Run a consistency check by sampling random pattern IDs from SQLite,
+     * searching for them in both engines, and comparing results.
+     */
+    runCheck(): ConsistencyCheckResult;
+    /**
+     * Get the aggregate divergence rate over the rolling window.
+     */
+    getRollingDivergenceRate(): number;
+    /**
+     * Get the number of consistency checks performed in the rolling window.
+     */
+    getCheckCount(): number;
+    /**
+     * Get all check results in the rolling window.
+     */
+    getHistory(): ConsistencyCheckResult[];
+    private getSampleIds;
+    private getSqliteEmbedding;
+    private triggerCompaction;
+    private pruneHistory;
+}
+export {};
+//# sourceMappingURL=rvf-consistency-validator.d.ts.map

package/dist/persistence/rvf-consistency-validator.js

@@ -0,0 +1,182 @@
+/**
+ * RVF Consistency Validator (ADR-072)
+ *
+ * Periodically samples reads from both SQLite and RVF engines, compares
+ * results, and tracks divergence rate over a rolling window. Monitors
+ * RVF deadSpaceRatio and triggers compaction when needed.
+ *
+ * Used by RvfStageGate to make go/no-go decisions for stage promotion.
+ *
+ * @module persistence/rvf-consistency-validator
+ */
+const DEFAULT_CONFIG = {
+    sampleSize: 50,
+    windowDurationMs: 7 * 24 * 60 * 60 * 1000, // 7 days
+    compactionThreshold: 0.3,
+    scoreTolerance: 0.05,
+};
+// ============================================================================
+// RvfConsistencyValidator
+// ============================================================================
+export class RvfConsistencyValidator {
+    config;
+    db = null;
+    rvfStore = null;
+    history = [];
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    setSqliteDb(db) { this.db = db; }
+    setRvfStore(store) { this.rvfStore = store; }
+    // --------------------------------------------------------------------------
+    // Consistency Check
+    // --------------------------------------------------------------------------
+    /**
+     * Run a consistency check by sampling random pattern IDs from SQLite,
+     * searching for them in both engines, and comparing results.
+     */
+    runCheck() {
+        const result = {
+            timestamp: Date.now(),
+            samplesChecked: 0,
+            divergences: 0,
+            divergenceRate: 0,
+            details: [],
+            deadSpaceRatio: null,
+            compactionTriggered: false,
+        };
+        if (!this.db || !this.rvfStore) {
+            this.history.push(result);
+            return result;
+        }
+        // 1. Get random sample of pattern IDs from SQLite
+        const sampleIds = this.getSampleIds(this.config.sampleSize);
+        result.samplesChecked = sampleIds.length;
+        if (sampleIds.length === 0) {
+            this.history.push(result);
+            return result;
+        }
+        // 2. For each sample, get embedding from SQLite and search both engines
+        for (const patternId of sampleIds) {
+            const embedding = this.getSqliteEmbedding(patternId);
+            if (!embedding) {
+                result.divergences++;
+                result.details.push({ patternId, issue: 'missing-in-sqlite' });
+                continue;
+            }
+            // Search RVF
+            try {
+                const rvfResults = this.rvfStore.search(embedding, 1);
+                if (rvfResults.length === 0) {
+                    result.divergences++;
+                    result.details.push({ patternId, issue: 'missing-in-rvf' });
+                }
+                // If RVF returns results, check that the top result ID matches
+                // (self-search should return the same pattern as top-1)
+                else if (rvfResults[0].id !== patternId && rvfResults[0].score < 0.99) {
+                    result.divergences++;
+                    result.details.push({
+                        patternId,
+                        issue: 'score-mismatch',
+                        rvfScore: rvfResults[0].score,
+                    });
+                }
+            }
+            catch {
+                result.divergences++;
+                result.details.push({ patternId, issue: 'missing-in-rvf' });
+            }
+        }
+        result.divergenceRate = result.samplesChecked > 0
+            ? result.divergences / result.samplesChecked
+            : 0;
+        // 3. Check dead space ratio and trigger compaction if needed
+        try {
+            const rvfStatus = this.rvfStore.status();
+            const deadSpace = rvfStatus.deadSpaceRatio;
+            result.deadSpaceRatio = deadSpace ?? null;
+            if (deadSpace != null && deadSpace > this.config.compactionThreshold) {
+                this.triggerCompaction();
+                result.compactionTriggered = true;
+            }
+        }
+        catch {
+            // Status check is best-effort
+        }
+        // 4. Add to history and prune old entries
+        this.history.push(result);
+        this.pruneHistory();
+        return result;
+    }
+    // --------------------------------------------------------------------------
+    // Rolling Window Metrics
+    // --------------------------------------------------------------------------
+    /**
+     * Get the aggregate divergence rate over the rolling window.
+     */
+    getRollingDivergenceRate() {
+        const windowStart = Date.now() - this.config.windowDurationMs;
+        const inWindow = this.history.filter(h => h.timestamp >= windowStart);
+        if (inWindow.length === 0)
+            return 0;
+        const totalSamples = inWindow.reduce((s, h) => s + h.samplesChecked, 0);
+        const totalDivergences = inWindow.reduce((s, h) => s + h.divergences, 0);
+        return totalSamples > 0 ? totalDivergences / totalSamples : 0;
+    }
+    /**
+     * Get the number of consistency checks performed in the rolling window.
+     */
+    getCheckCount() {
+        const windowStart = Date.now() - this.config.windowDurationMs;
+        return this.history.filter(h => h.timestamp >= windowStart).length;
+    }
+    /**
+     * Get all check results in the rolling window.
+     */
+    getHistory() {
+        const windowStart = Date.now() - this.config.windowDurationMs;
+        return this.history.filter(h => h.timestamp >= windowStart);
+    }
+    // --------------------------------------------------------------------------
+    // Private
+    // --------------------------------------------------------------------------
+    getSampleIds(count) {
+        if (!this.db)
+            return [];
+        try {
+            const rows = this.db.prepare(`SELECT pattern_id FROM qe_pattern_embeddings ORDER BY RANDOM() LIMIT ?`).all(count);
+            return rows.map(r => r.pattern_id);
+        }
+        catch {
+            return [];
+        }
+    }
+    getSqliteEmbedding(patternId) {
+        if (!this.db)
+            return null;
+        try {
+            const row = this.db.prepare('SELECT embedding, dimension FROM qe_pattern_embeddings WHERE pattern_id = ?').get(patternId);
+            if (!row)
+                return null;
+            return new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.dimension);
+        }
+        catch {
+            return null;
+        }
+    }
+    triggerCompaction() {
+        // RVF compaction via the store's compact method (if available)
+        try {
+            const store = this.rvfStore;
+            store.compact?.();
+        }
+        catch {
+            // Compaction is best-effort
+        }
+    }
+    pruneHistory() {
+        const cutoff = Date.now() - this.config.windowDurationMs;
+        this.history = this.history.filter(h => h.timestamp >= cutoff);
+    }
+}
+//# sourceMappingURL=rvf-consistency-validator.js.map

package/dist/persistence/rvf-migration-adapter.d.ts

@@ -0,0 +1,125 @@
+/**
+ * RVF Migration Adapter (ADR-072)
+ *
+ * Extends RvfDualWriter concepts to all persistence operations (KV, Q-values,
+ * GOAP state). Routes reads and writes based on the rvfMigrationStage config:
+ *
+ *   Stage 0: SQLite only (legacy)
+ *   Stage 1: Hybrid (current — vectors in RVF, metadata in SQLite)
+ *   Stage 2: Dual-write, read from SQLite (both engines receive writes)
+ *   Stage 3: Dual-write, read from RVF (both engines receive writes)
+ *   Stage 4: RVF primary, SQLite escape hatch
+ *
+ * Each stage is reversible by changing the config — no data is lost.
+ *
+ * @module persistence/rvf-migration-adapter
+ */
+import type { RvfStore, RvfStatus } from '../integrations/ruvector/rvf-dual-writer.js';
+export type MigrationStage = 0 | 1 | 2 | 3 | 4;
+export declare const STAGE_NAMES: Record<MigrationStage, string>;
+export interface MigrationAdapterConfig {
+    /** Current migration stage */
+    stage: MigrationStage;
+    /** Path to RVF container */
+    rvfPath: string;
+    /** Vector dimensions (default: 384) */
+    dimensions: number;
+    /** Enable fallback on RVF read failure in stage 3+ */
+    enableFallback: boolean;
+}
+export interface WriteResult {
+    sqliteSuccess: boolean;
+    rvfSuccess: boolean;
+    stage: MigrationStage;
+    fallbackUsed: boolean;
+}
+export interface ReadResult<T> {
+    data: T | null;
+    source: 'sqlite' | 'rvf' | 'fallback';
+    latencyMs: number;
+    stage: MigrationStage;
+}
+export interface MigrationMetrics {
+    stage: MigrationStage;
+    stageName: string;
+    totalWrites: number;
+    totalReads: number;
+    rvfWriteFailures: number;
+    rvfReadFailures: number;
+    fallbacksUsed: number;
+    sqliteReadLatencyAvgMs: number;
+    rvfReadLatencyAvgMs: number;
+    sqliteWriteLatencyAvgMs: number;
+    rvfWriteLatencyAvgMs: number;
+}
+interface SqliteDb {
+    prepare(sql: string): {
+        run(...params: unknown[]): {
+            changes: number;
+        };
+        get(...params: unknown[]): unknown;
+        all(...params: unknown[]): unknown[];
+    };
+}
+export declare class RvfMigrationAdapter {
+    private config;
+    private db;
+    private rvfStore;
+    private totalWrites;
+    private totalReads;
+    private rvfWriteFailures;
+    private rvfReadFailures;
+    private fallbacksUsed;
+    private sqliteLatencies;
+    private rvfLatencies;
+    private sqliteWriteLatencies;
+    private rvfWriteLatencies;
+    constructor(config: Partial<MigrationAdapterConfig> & {
+        stage: MigrationStage;
+    });
+    /** Attach a SQLite database handle */
+    setSqliteDb(db: SqliteDb): void;
+    /** Attach an RVF store */
+    setRvfStore(store: RvfStore): void;
+    /** Get current migration stage */
+    get stage(): MigrationStage;
+    /** Update migration stage (called by coordinator on promotion) */
+    setStage(stage: MigrationStage): void;
+    /**
+     * Write a vector to the appropriate store(s) based on migration stage.
+     *
+     * Stage 0-1: SQLite only (vectors as BLOBs or hybrid)
+     * Stage 2-3: Both engines receive writes
+     * Stage 4:   RVF only, SQLite escape hatch on failure
+     */
+    write(id: string, vector: Float32Array | number[]): WriteResult;
+    /**
+     * Delete a vector from the appropriate store(s).
+     */
+    delete(id: string): WriteResult;
+    /**
+     * Search for similar vectors, routing to the appropriate engine.
+     *
+     * Stage 0-2: Read from SQLite
+     * Stage 3-4: Read from RVF, fallback to SQLite on error
+     */
+    search(query: Float32Array | number[], k: number): ReadResult<Array<{
+        id: string;
+        score: number;
+    }>>;
+    /** Get combined status from both engines */
+    status(): {
+        sqlite: {
+            vectorCount: number;
+        };
+        rvf: RvfStatus | null;
+        stage: MigrationStage;
+    };
+    /** Get aggregated migration metrics */
+    getMetrics(): MigrationMetrics;
+    /** Reset metrics counters */
+    resetMetrics(): void;
+    private searchSqlite;
+}
+export {};
+//# sourceMappingURL=rvf-migration-adapter.d.ts.map

package/dist/persistence/rvf-migration-adapter.js

@@ -0,0 +1,303 @@
+/**
+ * RVF Migration Adapter (ADR-072)
+ *
+ * Extends RvfDualWriter concepts to all persistence operations (KV, Q-values,
+ * GOAP state). Routes reads and writes based on the rvfMigrationStage config:
+ *
+ *   Stage 0: SQLite only (legacy)
+ *   Stage 1: Hybrid (current — vectors in RVF, metadata in SQLite)
+ *   Stage 2: Dual-write, read from SQLite (both engines receive writes)
+ *   Stage 3: Dual-write, read from RVF (both engines receive writes)
+ *   Stage 4: RVF primary, SQLite escape hatch
+ *
+ * Each stage is reversible by changing the config — no data is lost.
+ *
+ * @module persistence/rvf-migration-adapter
+ */
+export const STAGE_NAMES = {
+    0: 'sqlite-only',
+    1: 'hybrid',
+    2: 'dual-write-sqlite-primary',
+    3: 'dual-write-rvf-primary',
+    4: 'rvf-primary',
+};
+// ============================================================================
+// RvfMigrationAdapter
+// ============================================================================
+export class RvfMigrationAdapter {
+    config;
+    db = null;
+    rvfStore = null;
+    // Metrics tracking
+    totalWrites = 0;
+    totalReads = 0;
+    rvfWriteFailures = 0;
+    rvfReadFailures = 0;
+    fallbacksUsed = 0;
+    sqliteLatencies = [];
+    rvfLatencies = [];
+    sqliteWriteLatencies = [];
+    rvfWriteLatencies = [];
+    constructor(config) {
+        this.config = {
+            rvfPath: '.agentic-qe/patterns.rvf',
+            dimensions: 384,
+            enableFallback: true,
+            ...config,
+        };
+    }
+    /** Attach a SQLite database handle */
+    setSqliteDb(db) {
+        this.db = db;
+    }
+    /** Attach an RVF store */
+    setRvfStore(store) {
+        this.rvfStore = store;
+    }
+    /** Get current migration stage */
+    get stage() {
+        return this.config.stage;
+    }
+    /** Update migration stage (called by coordinator on promotion) */
+    setStage(stage) {
+        this.config = { ...this.config, stage };
+    }
+    // --------------------------------------------------------------------------
+    // Write Operations
+    // --------------------------------------------------------------------------
+    /**
+     * Write a vector to the appropriate store(s) based on migration stage.
+     *
+     * Stage 0-1: SQLite only (vectors as BLOBs or hybrid)
+     * Stage 2-3: Both engines receive writes
+     * Stage 4:   RVF only, SQLite escape hatch on failure
+     */
+    write(id, vector) {
+        this.totalWrites++;
+        const result = {
+            sqliteSuccess: false,
+            rvfSuccess: false,
+            stage: this.config.stage,
+            fallbackUsed: false,
+        };
+        const shouldWriteSqlite = this.config.stage < 4;
+        const shouldWriteRvf = this.config.stage >= 2;
+        // Write to SQLite
+        if (shouldWriteSqlite && this.db) {
+            const start = performance.now();
+            try {
+                const blob = Buffer.from(vector instanceof Float32Array ? vector.buffer : new Float32Array(vector).buffer);
+                this.db.prepare(`
+          INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, created_at)
+          VALUES (?, ?, ?, 'all-MiniLM-L6-v2', datetime('now'))
+          ON CONFLICT(pattern_id) DO UPDATE SET
+            embedding = excluded.embedding, dimension = excluded.dimension, created_at = datetime('now')
+        `).run(id, blob, vector.length);
+                result.sqliteSuccess = true;
+                this.sqliteWriteLatencies.push(performance.now() - start);
+            }
+            catch (err) {
+                result.sqliteSuccess = false;
+                if (process.env.AQE_DEBUG_MIGRATION) {
+                    console.warn('[RVF-Migration] SQLite write failed:', err.message);
+                }
+            }
+        }
+        // Write to RVF
+        if (shouldWriteRvf && this.rvfStore) {
+            const start = performance.now();
+            try {
+                this.rvfStore.ingest([{ id, vector }]);
+                result.rvfSuccess = true;
+                this.rvfWriteLatencies.push(performance.now() - start);
+            }
+            catch {
+                this.rvfWriteFailures++;
+                result.rvfSuccess = false;
+            }
+        }
+        // Stage 4: If RVF write failed, fall back to SQLite
+        if (this.config.stage === 4 && !result.rvfSuccess && this.config.enableFallback && this.db) {
+            try {
+                const blob = Buffer.from(vector instanceof Float32Array ? vector.buffer : new Float32Array(vector).buffer);
+                this.db.prepare(`
+          INSERT INTO qe_pattern_embeddings (pattern_id, embedding, dimension, model, created_at)
+          VALUES (?, ?, ?, 'all-MiniLM-L6-v2', datetime('now'))
+          ON CONFLICT(pattern_id) DO UPDATE SET
+            embedding = excluded.embedding, dimension = excluded.dimension, created_at = datetime('now')
+        `).run(id, blob, vector.length);
+                result.sqliteSuccess = true;
+                result.fallbackUsed = true;
+                this.fallbacksUsed++;
+            }
+            catch {
+                // Both engines failed
+            }
+        }
+        return result;
+    }
+    /**
+     * Delete a vector from the appropriate store(s).
+     */
+    delete(id) {
+        this.totalWrites++;
+        const result = {
+            sqliteSuccess: false,
+            rvfSuccess: false,
+            stage: this.config.stage,
+            fallbackUsed: false,
+        };
+        if (this.config.stage < 4 && this.db) {
+            try {
+                this.db.prepare('DELETE FROM qe_pattern_embeddings WHERE pattern_id = ?').run(id);
+                result.sqliteSuccess = true;
+            }
+            catch { /* best effort */ }
+        }
+        if (this.config.stage >= 2 && this.rvfStore) {
+            try {
+                this.rvfStore.delete([id]);
+                result.rvfSuccess = true;
+            }
+            catch {
+                this.rvfWriteFailures++;
+            }
+        }
+        return result;
+    }
+    // --------------------------------------------------------------------------
+    // Read Operations
+    // --------------------------------------------------------------------------
+    /**
+     * Search for similar vectors, routing to the appropriate engine.
+     *
+     * Stage 0-2: Read from SQLite
+     * Stage 3-4: Read from RVF, fallback to SQLite on error
+     */
+    search(query, k) {
+        this.totalReads++;
+        const useRvf = this.config.stage >= 3;
+        if (useRvf && this.rvfStore) {
+            const start = performance.now();
+            try {
+                const results = this.rvfStore.search(query, k);
+                const latency = performance.now() - start;
+                this.rvfLatencies.push(latency);
+                return { data: results, source: 'rvf', latencyMs: latency, stage: this.config.stage };
+            }
+            catch {
+                this.rvfReadFailures++;
+                // Fall through to SQLite if fallback enabled
+                if (!this.config.enableFallback) {
+                    return { data: null, source: 'rvf', latencyMs: 0, stage: this.config.stage };
+                }
+                this.fallbacksUsed++;
+            }
+        }
+        // SQLite read (stages 0-2 or fallback)
+        const start = performance.now();
+        const results = this.searchSqlite(query, k);
+        const latency = performance.now() - start;
+        this.sqliteLatencies.push(latency);
+        return {
+            data: results,
+            source: useRvf ? 'fallback' : 'sqlite',
+            latencyMs: latency,
+            stage: this.config.stage,
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Status & Metrics
+    // --------------------------------------------------------------------------
+    /** Get combined status from both engines */
+    status() {
+        let sqliteCount = 0;
+        if (this.db) {
+            try {
+                const row = this.db.prepare('SELECT COUNT(*) as cnt FROM qe_pattern_embeddings').get();
+                sqliteCount = row?.cnt ?? 0;
+            }
+            catch { /* table may not exist */ }
+        }
+        let rvfStatus = null;
+        if (this.rvfStore) {
+            try {
+                rvfStatus = this.rvfStore.status();
+            }
+            catch { /* best effort */ }
+        }
+        return { sqlite: { vectorCount: sqliteCount }, rvf: rvfStatus, stage: this.config.stage };
+    }
+    /** Get aggregated migration metrics */
+    getMetrics() {
+        return {
+            stage: this.config.stage,
+            stageName: STAGE_NAMES[this.config.stage],
+            totalWrites: this.totalWrites,
+            totalReads: this.totalReads,
+            rvfWriteFailures: this.rvfWriteFailures,
+            rvfReadFailures: this.rvfReadFailures,
+            fallbacksUsed: this.fallbacksUsed,
+            sqliteReadLatencyAvgMs: avg(this.sqliteLatencies),
+            rvfReadLatencyAvgMs: avg(this.rvfLatencies),
+            sqliteWriteLatencyAvgMs: avg(this.sqliteWriteLatencies),
+            rvfWriteLatencyAvgMs: avg(this.rvfWriteLatencies),
+        };
+    }
+    /** Reset metrics counters */
+    resetMetrics() {
+        this.totalWrites = 0;
+        this.totalReads = 0;
+        this.rvfWriteFailures = 0;
+        this.rvfReadFailures = 0;
+        this.fallbacksUsed = 0;
+        this.sqliteLatencies = [];
+        this.rvfLatencies = [];
+        this.sqliteWriteLatencies = [];
+        this.rvfWriteLatencies = [];
+    }
+    // --------------------------------------------------------------------------
+    // Private
+    // --------------------------------------------------------------------------
+    searchSqlite(query, k) {
+        if (!this.db)
+            return [];
+        let rows;
+        try {
+            rows = this.db.prepare('SELECT pattern_id, embedding, dimension FROM qe_pattern_embeddings').all();
+        }
+        catch {
+            return [];
+        }
+        const queryArr = query instanceof Float32Array ? Array.from(query) : query;
+        const queryMag = Math.sqrt(queryArr.reduce((s, v) => s + v * v, 0));
+        if (queryMag === 0)
+            return [];
+        const scored = [];
+        for (const row of rows) {
+            if (row.dimension !== queryArr.length)
+                continue;
+            const stored = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.dimension);
+            let dot = 0, storedMag = 0;
+            for (let i = 0; i < row.dimension; i++) {
+                dot += queryArr[i] * stored[i];
+                storedMag += stored[i] * stored[i];
+            }
+            storedMag = Math.sqrt(storedMag);
+            if (storedMag === 0)
+                continue;
+            scored.push({ id: row.pattern_id, score: dot / (queryMag * storedMag) });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, k);
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function avg(arr) {
+    if (arr.length === 0)
+        return 0;
+    return arr.reduce((s, v) => s + v, 0) / arr.length;
+}
+//# sourceMappingURL=rvf-migration-adapter.js.map