squish-memory 1.2.0 → 1.2.1

package/dist/core/temporal-facts.d.ts

@@ -1,54 +0,0 @@
-/**
- * Temporal Facts System
- * Manages versioned facts with validity windows
- */
-/**
- * Store a new fact with temporal validity
- */
-export declare function storeFact(content: string, options?: {
-    validFrom?: Date;
-    validTo?: Date;
-    confidence?: number;
-    tags?: string[];
-    projectId?: string;
-}): Promise<string>;
-/**
- * Update a fact by creating a new version
- */
-export declare function updateFact(previousFactId: string, newContent: string, reason: string): Promise<string>;
-/**
- * Query facts valid at a specific point in time
- */
-export declare function queryFactsAtTime(timestamp?: Date, options?: {
-    minConfidence?: number;
-    tags?: string[];
-    projectId?: string;
-    limit?: number;
-}): Promise<any[]>;
-/**
- * Get the complete version history of a fact
- */
-export declare function getFactHistory(factId: string): Promise<any[]>;
-/**
- * Apply confidence decay based on temporal distance
- */
-export declare function applyConfidenceDecay(factId: string, ageDays: number): Promise<void>;
-/**
- * Invalidate a fact (mark as no longer valid)
- */
-export declare function invalidateFact(factId: string, reason: string): Promise<void>;
-/**
- * Check if a fact is currently valid
- */
-export declare function isFactValid(factId: string, atTime?: Date): Promise<boolean>;
-/**
- * Get statistics about facts
- */
-export declare function getFactStats(projectId?: string): Promise<{
-    totalFacts: number;
-    activeFacts: number;
-    expiredFacts: number;
-    avgConfidence: number;
-    avgAge: number;
-}>;
-//# sourceMappingURL=temporal-facts.d.ts.map

package/dist/core/temporal-facts.js

@@ -1,193 +0,0 @@
-/**
- * Temporal Facts System
- * Manages versioned facts with validity windows
- */
-import { and, eq, gte, desc } from 'drizzle-orm';
-import { randomUUID } from 'crypto';
-import { getDb } from '../db/index.js';
-import { getSchema } from '../db/schema.js';
-import { traverseSupersededChain } from './utils/history-traversal.js';
-import { createNewFactVersion } from './utils/version-management.js';
-import { buildFactAtTimeQuery } from './utils/temporal-queries.js';
-import { logger } from './logger.js';
-/**
- * Store a new fact with temporal validity
- */
-export async function storeFact(content, options = {}) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const factId = randomUUID();
-        await db.insert(schema.memories).values({
-            id: factId,
-            type: 'fact',
-            sector: 'semantic',
-            content,
-            confidence: options.confidence || 100,
-            validFrom: options.validFrom || new Date(),
-            validTo: options.validTo || null,
-            version: 1,
-            tags: options.tags || [],
-            projectId: options.projectId || null,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        });
-        return factId;
-    }
-    catch (error) {
-        logger.error('Error storing fact', error);
-        throw error;
-    }
-}
-/**
- * Update a fact by creating a new version
- */
-export async function updateFact(previousFactId, newContent, reason) {
-    return createNewFactVersion(previousFactId, newContent, {}, reason);
-}
-/**
- * Query facts valid at a specific point in time
- */
-export async function queryFactsAtTime(timestamp = new Date(), options = {}) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const minConfidence = options.minConfidence || 0;
-        const limit = options.limit || 100;
-        const additionalFilters = [gte(schema.memories.confidence, minConfidence)];
-        if (options.projectId) {
-            additionalFilters.push(eq(schema.memories.projectId, options.projectId));
-        }
-        const where = buildFactAtTimeQuery(schema, timestamp, additionalFilters);
-        const results = await db
-            .select()
-            .from(schema.memories)
-            .where(where)
-            .orderBy(desc(schema.memories.confidence))
-            .limit(limit);
-        return results;
-    }
-    catch (error) {
-        logger.error('Error querying facts at time', error);
-        return [];
-    }
-}
-/**
- * Get the complete version history of a fact
- */
-export async function getFactHistory(factId) {
-    return traverseSupersededChain(factId);
-}
-/**
- * Apply confidence decay based on temporal distance
- */
-export async function applyConfidenceDecay(factId, ageDays) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Confidence decays exponentially: newConfidence = originalConfidence * e^(-lambda * ageDays)
-        // Using lambda = 0.01 for moderate decay
-        const decayFactor = Math.exp(-0.01 * ageDays);
-        const fact = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, factId))
-            .limit(1);
-        if (fact.length === 0)
-            return;
-        const newConfidence = Math.max(0, Math.floor(fact[0].confidence * decayFactor));
-        await db
-            .update(schema.memories)
-            .set({ confidence: newConfidence })
-            .where(eq(schema.memories.id, factId));
-    }
-    catch (error) {
-        logger.error('Error applying confidence decay', error);
-    }
-}
-/**
- * Invalidate a fact (mark as no longer valid)
- */
-export async function invalidateFact(factId, reason) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        await db
-            .update(schema.memories)
-            .set({
-            validTo: new Date(),
-            metadata: { invalidationReason: reason, invalidatedAt: new Date().toISOString() },
-        })
-            .where(eq(schema.memories.id, factId));
-    }
-    catch (error) {
-        logger.error('Error invalidating fact', error);
-    }
-}
-/**
- * Check if a fact is currently valid
- */
-export async function isFactValid(factId, atTime = new Date()) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const additionalFilters = [eq(schema.memories.id, factId)];
-        const where = buildFactAtTimeQuery(schema, atTime, additionalFilters);
-        const fact = await db
-            .select()
-            .from(schema.memories)
-            .where(where)
-            .limit(1);
-        return fact.length > 0;
-    }
-    catch (error) {
-        logger.error('Error checking fact validity', error);
-        return false;
-    }
-}
-/**
- * Get statistics about facts
- */
-export async function getFactStats(projectId) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const now = new Date();
-        const where = projectId
-            ? and(eq(schema.memories.type, 'fact'), eq(schema.memories.projectId, projectId))
-            : eq(schema.memories.type, 'fact');
-        const facts = await db.select().from(schema.memories).where(where);
-        let active = 0;
-        let expired = 0;
-        let totalConfidence = 0;
-        let totalAge = 0;
-        for (const fact of facts) {
-            totalConfidence += fact.confidence || 0;
-            if (fact.validTo && new Date(fact.validTo) < now) {
-                expired++;
-            }
-            else if (!fact.validTo || new Date(fact.validTo) >= now) {
-                active++;
-            }
-            totalAge += (now.getTime() - new Date(fact.createdAt).getTime()) / (1000 * 60 * 60 * 24);
-        }
-        return {
-            totalFacts: facts.length,
-            activeFacts: active,
-            expiredFacts: expired,
-            avgConfidence: facts.length > 0 ? totalConfidence / facts.length : 0,
-            avgAge: facts.length > 0 ? totalAge / facts.length : 0,
-        };
-    }
-    catch (error) {
-        logger.error('Error getting fact stats', error);
-        return {
-            totalFacts: 0,
-            activeFacts: 0,
-            expiredFacts: 0,
-            avgConfidence: 0,
-            avgAge: 0,
-        };
-    }
-}
-//# sourceMappingURL=temporal-facts.js.map

package/dist/core/tracing/collector.d.ts

@@ -1,111 +0,0 @@
-/** Trace Collector - Collects search pipeline traces for debugging and performance analysis
- *
- * Trace storage format - All search operations are logged with timing information
- * Trace retrieval - Get traces by session or ID
- */
-export interface SearchTrace {
-    id: string;
-    sessionId: string | null;
-    query: string;
-    timestamp: Date;
-    totalDurationMs: number;
-    metadata: Record<string, unknown>;
-    queryRewrite?: QueryRewriteStage;
-    candidateRetrieval?: RetrievalStage;
-    entityFiltering?: RetrievalStage;
-    hybridScoring?: ScoringStage;
-    reranking?: RerankingStage;
-    resultCount?: number;
-    topResults?: TopResult[];
-}
-export interface QueryRewriteStage {
-    original?: string;
-    rewritten?: string;
-    method?: string;
-    timeMs?: number;
-}
-export interface RetrievalStage {
-    candidates?: number;
-    results?: number;
-    timeMs?: number;
-    entities?: string[];
-}
-export interface ScoringStage {
-    results?: number;
-    timeMs?: number;
-}
-export interface RerankingStage {
-    results?: number;
-    timeMs?: number;
-}
-export interface TopResult {
-    type?: string;
-    content?: string;
-    hybridScore?: number;
-}
-export interface TraceOptions {
-    sessionId?: string;
-    limit?: number;
-    session?: string;
-}
-export interface TraceStats {
-    totalTraces: number;
-    totalDurationMs: number;
-    avgDurationMs: number;
-    recentSessions: number;
-    totalErrors: number;
-    errorRate: number;
-}
-/**
- * Start a new search trace collection
- */
-export declare function startTrace(sessionId: string, query: string): Promise<string>;
-/**
- * Add query rewrite stage data
- */
-export declare function addQueryRewriteStage(traceId: string, stage: QueryRewriteStage): Promise<void>;
-/**
- * Add candidate retrieval stage data
- */
-export declare function addCandidateRetrievalStage(traceId: string, stage: RetrievalStage): Promise<void>;
-/**
- * Add entity filtering stage data
- */
-export declare function addEntityFilteringStage(traceId: string, stage: RetrievalStage): Promise<void>;
-/**
- * Add hybrid scoring stage data
- */
-export declare function addHybridScoringStage(traceId: string, stage: ScoringStage): Promise<void>;
-/**
- * Add reranking stage data
- */
-export declare function addRerankingStage(traceId: string, stage: RerankingStage): Promise<void>;
-/**
- * Complete current trace (all stages done)
- */
-export declare function completeTrace(traceId: string, results: TopResult[]): Promise<void>;
-/**
- * Get traces for a session
- */
-export declare function getTraces(options?: TraceOptions): Promise<SearchTrace[]>;
-/**
- * Get a specific trace by ID
- */
-export declare function getTraceById(traceId: string): Promise<SearchTrace | null>;
-/**
- * Get recent traces (limited)
- */
-export declare function getRecentTraces(limit?: number): Promise<SearchTrace[]>;
-/**
- * Get recent session summary traces (aggregated by session)
- */
-export declare function getSessionTraces(sessionId: string): Promise<SearchTrace[]>;
-/**
- * Create visual ASCII visualization of a trace
- */
-export declare function visualizeTrace(trace: SearchTrace): string;
-/**
- * Get trace statistics (performance metrics)
- */
-export declare function getTraceStats(): Promise<TraceStats>;
-//# sourceMappingURL=collector.d.ts.map

package/dist/core/tracing/collector.js

@@ -1,350 +0,0 @@
-/** Trace Collector - Collects search pipeline traces for debugging and performance analysis
- *
- * Trace storage format - All search operations are logged with timing information
- * Trace retrieval - Get traces by session or ID
- */
-import { logger } from '../logger.js';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { eq, desc, sql } from 'drizzle-orm';
-/**
- * Start a new search trace collection
- */
-export async function startTrace(sessionId, query) {
-    const db = await getDb();
-    if (!db) {
-        logger.error('Database unavailable for trace collection');
-        return '';
-    }
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const traceId = crypto.randomUUID();
-    const timestamp = new Date();
-    // Create trace record
-    await sqliteDb.insert(schema.searchTraces).values({
-        id: traceId,
-        sessionId,
-        query,
-        timestamp,
-        resultCount: 0,
-        totalDurationMs: 0,
-    });
-    logger.info(`[Tracing] Started trace ${traceId}`);
-    return traceId;
-}
-/**
- * Add query rewrite stage data
- */
-export async function addQueryRewriteStage(traceId, stage) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const data = JSON.stringify(stage);
-    await sqliteDb.update(schema.searchTraces)
-        .set({
-        queryRewrite: sql `CAST(? AS jsonb)`,
-    })
-        .where(eq(schema.searchTraces.id, traceId))
-        .set({ queryRewrite: data });
-    logger.debug(`[Tracing] Added queryRewrite stage to trace ${traceId}`);
-}
-/**
- * Add candidate retrieval stage data
- */
-export async function addCandidateRetrievalStage(traceId, stage) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const data = JSON.stringify(stage);
-    await sqliteDb.update(schema.searchTraces)
-        .set({ candidateRetrieval: data })
-        .where(eq(schema.searchTraces.id, traceId));
-    logger.debug(`[Tracing] Added candidateRetrieval stage to trace ${traceId}`);
-}
-/**
- * Add entity filtering stage data
- */
-export async function addEntityFilteringStage(traceId, stage) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const data = JSON.stringify(stage);
-    await sqliteDb.update(schema.searchTraces)
-        .set({ entityFiltering: data })
-        .where(eq(schema.searchTraces.id, traceId));
-    logger.debug(`[Tracing] Added entityFiltering stage to trace ${traceId}`);
-}
-/**
- * Add hybrid scoring stage data
- */
-export async function addHybridScoringStage(traceId, stage) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const data = JSON.stringify(stage);
-    await sqliteDb.update(schema.searchTraces)
-        .set({ hybridScoring: data })
-        .where(eq(schema.searchTraces.id, traceId));
-    logger.debug(`[Tracing] Added hybridScoring stage to trace ${traceId}`);
-}
-/**
- * Add reranking stage data
- */
-export async function addRerankingStage(traceId, stage) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const data = JSON.stringify(stage);
-    await sqliteDb.update(schema.searchTraces)
-        .set({ reranking: data })
-        .where(eq(schema.searchTraces.id, traceId));
-    logger.debug(`[Tracing] Added reranking stage to trace ${traceId}`);
-}
-/**
- * Complete current trace (all stages done)
- */
-export async function completeTrace(traceId, results) {
-    const db = await getDb();
-    if (!db)
-        return;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    // Get trace
-    const rows = await sqliteDb.select()
-        .from(schema.searchTraces)
-        .where(eq(schema.searchTraces.id, traceId))
-        .limit(1);
-    if (!rows || rows.length === 0) {
-        logger.warn(`[Tracing] Trace ${traceId} not found`);
-        return;
-    }
-    const trace = rows[0];
-    const startTime = trace.timestamp.getTime();
-    const endTime = Date.now();
-    const totalDurationMs = endTime - startTime;
-    const resultCount = results.length;
-    const topResults = results.slice(0, 10);
-    await sqliteDb.update(schema.searchTraces)
-        .set({
-        resultCount,
-        topResults: JSON.stringify(topResults),
-        totalDurationMs,
-    })
-        .where(eq(schema.searchTraces.id, traceId));
-    logger.info(`[Tracing] Completed trace ${traceId} with ${resultCount} results`);
-}
-/**
- * Get traces for a session
- */
-export async function getTraces(options = {}) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    let conditions = [];
-    if (options.sessionId) {
-        conditions.push(eq(schema.searchTraces.sessionId, options.sessionId));
-    }
-    if (options.session && options.session.length > 0) {
-        conditions.push(eq(schema.searchTraces.sessionId, options.session));
-    }
-    const query = sqliteDb.select()
-        .from(schema.searchTraces)
-        .where(conditions.length > 0 ? eq(schema.searchTraces.sessionId, options.sessionId || options.session || '') : undefined)
-        .orderBy(desc(schema.searchTraces.timestamp));
-    if (options.limit) {
-        query.limit(options.limit);
-    }
-    const traces = await query;
-    return traces.map((row) => ({
-        id: row.id,
-        sessionId: row.session_id,
-        query: row.query,
-        timestamp: row.timestamp,
-        totalDurationMs: row.total_duration_ms,
-        metadata: row.metadata ? JSON.parse(String(row.metadata)) : {},
-        queryRewrite: row.query_rewrite ? JSON.parse(String(row.query_rewrite)) : undefined,
-        candidateRetrieval: row.candidate_retrieval ? JSON.parse(String(row.candidate_retrieval)) : undefined,
-        entityFiltering: row.entity_filtering ? JSON.parse(String(row.entity_filtering)) : undefined,
-        hybridScoring: row.hybrid_scoring ? JSON.parse(String(row.hybrid_scoring)) : undefined,
-        reranking: row.reranking ? JSON.parse(String(row.reranking)) : undefined,
-        resultCount: row.result_count,
-        topResults: row.top_results ? JSON.parse(String(row.top_results)) : undefined,
-    }));
-}
-/**
- * Get a specific trace by ID
- */
-export async function getTraceById(traceId) {
-    const db = await getDb();
-    if (!db)
-        return null;
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const rows = await sqliteDb.select()
-        .from(schema.searchTraces)
-        .where(eq(schema.searchTraces.id, traceId))
-        .limit(1);
-    if (rows.length === 0)
-        return null;
-    const row = rows[0];
-    return {
-        id: row.id,
-        sessionId: row.session_id,
-        query: row.query,
-        timestamp: row.timestamp,
-        totalDurationMs: row.total_duration_ms,
-        metadata: row.metadata ? JSON.parse(String(row.metadata)) : {},
-        queryRewrite: row.query_rewrite ? JSON.parse(String(row.query_rewrite)) : undefined,
-        candidateRetrieval: row.candidate_retrieval ? JSON.parse(String(row.candidate_retrieval)) : undefined,
-        entityFiltering: row.entity_filtering ? JSON.parse(String(row.entity_filtering)) : undefined,
-        hybridScoring: row.hybrid_scoring ? JSON.parse(String(row.hybrid_scoring)) : undefined,
-        reranking: row.reranking ? JSON.parse(String(row.reranking)) : undefined,
-        resultCount: row.result_count,
-        topResults: row.top_results ? JSON.parse(String(row.top_results)) : undefined,
-    };
-}
-/**
- * Get recent traces (limited)
- */
-export async function getRecentTraces(limit = 10) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const traces = await sqliteDb.select()
-        .from(schema.searchTraces)
-        .orderBy(desc(schema.searchTraces.timestamp))
-        .limit(limit);
-    return traces.map((row) => ({
-        id: row.id,
-        sessionId: row.session_id,
-        query: row.query,
-        timestamp: row.timestamp,
-        totalDurationMs: row.total_duration_ms,
-        metadata: row.metadata ? JSON.parse(String(row.metadata)) : {},
-        queryRewrite: row.query_rewrite ? JSON.parse(String(row.query_rewrite)) : undefined,
-        candidateRetrieval: row.candidate_retrieval ? JSON.parse(String(row.candidate_retrieval)) : undefined,
-        entityFiltering: row.entity_filtering ? JSON.parse(String(row.entity_filtering)) : undefined,
-        hybridScoring: row.hybrid_scoring ? JSON.parse(String(row.hybrid_scoring)) : undefined,
-        reranking: row.reranking ? JSON.parse(String(row.reranking)) : undefined,
-        resultCount: row.result_count,
-        topResults: row.top_results ? JSON.parse(String(row.top_results)) : undefined,
-    }));
-}
-/**
- * Get recent session summary traces (aggregated by session)
- */
-export async function getSessionTraces(sessionId) {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const schema = await getSchema();
-    const sqliteDb = db;
-    // Get all traces for this session
-    const traces = await sqliteDb.select()
-        .from(schema.searchTraces)
-        .where(eq(schema.searchTraces.sessionId, sessionId))
-        .orderBy(desc(schema.searchTraces.timestamp));
-    if (traces.length === 0)
-        return [];
-    return traces.map((row) => ({
-        id: row.id,
-        sessionId: row.session_id,
-        query: row.query,
-        timestamp: row.timestamp,
-        totalDurationMs: row.total_duration_ms,
-        metadata: row.metadata ? JSON.parse(String(row.metadata)) : {},
-        queryRewrite: row.query_rewrite ? JSON.parse(String(row.query_rewrite)) : undefined,
-        candidateRetrieval: row.candidate_retrieval ? JSON.parse(String(row.candidate_retrieval)) : undefined,
-        entityFiltering: row.entity_filtering ? JSON.parse(String(row.entity_filtering)) : undefined,
-        hybridScoring: row.hybrid_scoring ? JSON.parse(String(row.hybrid_scoring)) : undefined,
-        reranking: row.reranking ? JSON.parse(String(row.reranking)) : undefined,
-        resultCount: row.result_count,
-        topResults: row.top_results ? JSON.parse(String(row.top_results)) : undefined,
-    }));
-}
-/**
- * Create visual ASCII visualization of a trace
- */
-export function visualizeTrace(trace) {
-    const lines = [];
-    // Header
-    lines.push(`Search Trace: ${trace.id}`);
-    lines.push(`Session: ${trace.sessionId || 'N/A'}`);
-    lines.push(`Query: "${trace.query}"`);
-    lines.push('');
-    // Total duration
-    lines.push(`Duration: ${trace.totalDurationMs}ms (${(trace.totalDurationMs / 1000).toFixed(2)}s)`);
-    lines.push('');
-    // Stages summary
-    const stageNames = [];
-    if (trace.queryRewrite)
-        stageNames.push(`Query Rewrite (${trace.queryRewrite.timeMs || 0}ms)`);
-    if (trace.candidateRetrieval)
-        stageNames.push(`Candidate Retrieval (${trace.candidateRetrieval.timeMs || 0}ms)`);
-    if (trace.entityFiltering)
-        stageNames.push(`Entity Filtering (${trace.entityFiltering.timeMs || 0}ms)`);
-    if (trace.hybridScoring)
-        stageNames.push(`Hybrid Scoring (${trace.hybridScoring.timeMs || 0}ms)`);
-    if (trace.reranking)
-        stageNames.push(`Reranking (${trace.reranking.timeMs || 0}ms)`);
-    if (stageNames.length > 0) {
-        lines.push('Stages:');
-        stageNames.forEach(name => lines.push(`  - ${name}`));
-    }
-    lines.push('');
-    // Top results
-    if (trace.topResults && trace.topResults.length > 0) {
-        lines.push(`Top Results (${trace.topResults.length}):`);
-        trace.topResults.slice(0, 5).forEach((result, i) => lines.push(`  ${i + 1}. [${result.type || 'memory'}] ${result.content?.substring(0, 50)}... (score: ${result.hybridScore?.toFixed(2)})`));
-    }
-    return lines.join('\n');
-}
-/**
- * Get trace statistics (performance metrics)
- */
-export async function getTraceStats() {
-    const db = await getDb();
-    if (!db) {
-        return {
-            totalTraces: 0,
-            totalDurationMs: 0,
-            avgDurationMs: 0,
-            recentSessions: 0,
-            totalErrors: 0,
-            errorRate: 0,
-        };
-    }
-    const schema = await getSchema();
-    const sqliteDb = db;
-    const traces = await sqliteDb.select()
-        .from(schema.searchTraces)
-        .limit(100);
-    const totalTraces = traces.length;
-    const totalDurationMs = traces.reduce((sum, t) => sum + (t.total_duration_ms || 0), 0);
-    const avgDurationMs = totalTraces > 0 ? Math.round(totalDurationMs / totalTraces) : 0;
-    const uniqueSessions = new Set(traces.map((t) => t.session_id).filter(Boolean));
-    const recentSessions = uniqueSessions.size;
-    return {
-        totalTraces,
-        totalDurationMs,
-        avgDurationMs,
-        recentSessions,
-        totalErrors: 0,
-        errorRate: 0,
-    };
-}
-//# sourceMappingURL=collector.js.map