squish-memory 1.1.5 → 1.2.1

package/dist/core/scheduler/cron-scheduler.js

@@ -1,332 +0,0 @@
-/** Cron Scheduler - Persistent cron-based job scheduling with fallback support */
-import cron from 'node-cron';
-import { selfIterationHandler } from '../session-hooks/self-iteration-job.js';
-import { runLifecycleMaintenance } from '../lifecycle.js';
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-import { getDb } from '../../db/index.js';
-import { maintenanceJobs, maintenanceJobHistory } from '../../db/drizzle/schema-sqlite.js';
-import { eq } from 'drizzle-orm';
-const jobHandlers = new Map();
-const activeTasks = new Map();
-export function registerJobHandler(jobName, handler) {
-    jobHandlers.set(jobName, handler);
-    logger.info(`[Scheduler] Registered handler for job: ${jobName}`);
-}
-// Register self-iteration job handler
-registerJobHandler('self_iteration', selfIterationHandler);
-// Decay job handler - runs lifecycle maintenance (decay, tier updates, eviction)
-const decayHandler = async (context) => {
-    const stats = await runLifecycleMaintenance();
-    return {
-        recordsProcessed: stats.decayed + stats.expired + stats.evicted,
-        summary: {
-            decayed: stats.decayed,
-            expired: stats.expired,
-            evicted: stats.evicted,
-            tierChanges: stats.tierChanges,
-        },
-    };
-};
-registerJobHandler('decay_maintenance', decayHandler);
-export async function initializeScheduler() {
-    if (!config.cronEnabled) {
-        logger.info('[Scheduler] Cron scheduling disabled, using heartbeat fallback');
-        return;
-    }
-    const db = await getDb();
-    if (!db) {
-        logger.warn('[Scheduler] Database not available, scheduler disabled');
-        return;
-    }
-    try {
-        await ensureDefaultJobs(db);
-        const sqliteDb = db;
-        const jobs = await sqliteDb
-            .select()
-            .from(maintenanceJobs)
-            .where(eq(maintenanceJobs.enabled, true));
-        for (const job of jobs) {
-            await scheduleJob(job);
-        }
-        logger.info(`[Scheduler] Initialized with ${jobs.length} scheduled jobs`);
-    }
-    catch (error) {
-        logger.error('[Scheduler] Failed to initialize:', error);
-    }
-}
-async function ensureDefaultJobs(db) {
-    const defaultJobs = [
-        {
-            jobName: 'decay_maintenance',
-            jobType: 'hourly',
-            cronExpression: '0 * * * *', // Run every hour at :00
-            enabled: true,
-            jobConfig: { applyDecay: true, updateTiers: true, evictOld: true },
-        },
-        {
-            jobName: 'nightly_maintenance',
-            jobType: 'nightly',
-            cronExpression: '0 2 * * *',
-            enabled: true,
-            jobConfig: { mergeDuplicates: true, boostAccessed: true, decayScores: true },
-        },
-        {
-            jobName: 'weekly_maintenance',
-            jobType: 'weekly',
-            cronExpression: '0 3 * * 0',
-            enabled: true,
-            jobConfig: { regenerateSummaries: true, archiveStale: true, cleanupOrphaned: true },
-        },
-        {
-            jobName: 'self_iteration',
-            jobType: 'hourly',
-            cronExpression: '30 * * * *', // Run every hour at :30
-            enabled: true,
-            jobConfig: { minMessageCount: 5, maxMessagesToProcess: 50 },
-        },
-    ];
-    for (const job of defaultJobs) {
-        let existing;
-        try {
-            existing = await db
-                .select()
-                .from(maintenanceJobs)
-                .where(eq(maintenanceJobs.jobName, job.jobName))
-                .limit(1);
-        }
-        catch (queryError) {
-            logger.error(`[Scheduler] Query failed for job ${job.jobName}:`, queryError.message);
-            // Try raw SQL fallback
-            try {
-                const rawDb = db.$client;
-                if (rawDb && typeof rawDb.prepare === 'function') {
-                    existing = rawDb.prepare('SELECT * FROM maintenance_jobs WHERE job_name = ?').all(job.jobName);
-                }
-            }
-            catch (fallbackError) {
-                logger.error(`[Scheduler] Fallback query also failed:`, fallbackError.message);
-                throw queryError;
-            }
-        }
-        if (existing.length === 0) {
-            try {
-                await db.insert(maintenanceJobs).values({
-                    jobName: job.jobName,
-                    jobType: job.jobType,
-                    cronExpression: job.cronExpression,
-                    enabled: job.enabled,
-                    jobConfig: job.jobConfig,
-                    totalRuns: 0,
-                    successCount: 0,
-                    failureCount: 0,
-                    lastRunAt: null,
-                    nextRunAt: null,
-                    lastRunDuration: null,
-                    lastRunStatus: null,
-                    lastRunError: null,
-                });
-            }
-            catch (insertError) {
-                // Fallback to raw SQL if drizzle insert fails
-                logger.warn(`[Scheduler] Drizzle insert failed, using raw SQL: ${insertError.message}`);
-                const rawDb = db.$client;
-                if (rawDb && typeof rawDb.prepare === 'function') {
-                    const stmt = rawDb.prepare(`
-            INSERT INTO maintenance_jobs 
-            (id, job_name, job_type, cron_expression, enabled, job_config, 
-             total_runs, success_count, failure_count, last_run_at, next_run_at, 
-             last_run_duration, last_run_status, last_run_error)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-          `);
-                    stmt.run(crypto.randomUUID(), job.jobName, job.jobType, job.cronExpression, job.enabled ? 1 : 0, JSON.stringify(job.jobConfig), 0, 0, 0, null, null, null, null, null);
-                }
-            }
-            logger.info(`[Scheduler] Created default job: ${job.jobName}`);
-            // Register self-iteration handler
-            if (job.jobName === 'self_iteration') {
-                registerJobHandler('self_iteration', selfIterationHandler);
-            }
-        }
-    }
-}
-export async function scheduleJob(job) {
-    const existingTask = activeTasks.get(job.jobName);
-    if (existingTask) {
-        existingTask.stop();
-        activeTasks.delete(job.jobName);
-    }
-    if (!job.enabled || !job.cronExpression) {
-        logger.debug(`[Scheduler] Job ${job.jobName} is disabled or has no cron expression`);
-        return;
-    }
-    if (!cron.validate(job.cronExpression)) {
-        logger.error(`[Scheduler] Invalid cron expression for ${job.jobName}: ${job.cronExpression}`);
-        return;
-    }
-    const task = cron.schedule(job.cronExpression, async () => {
-        await executeJob(job);
-    }, {
-        scheduled: true,
-        timezone: 'UTC',
-    });
-    activeTasks.set(job.jobName, task);
-    const nextRun = getNextRunTime(job.cronExpression);
-    const db = await getDb();
-    if (db) {
-        const sqliteDb = db;
-        await sqliteDb
-            .update(maintenanceJobs)
-            .set({ nextRunAt: nextRun })
-            .where(eq(maintenanceJobs.id, job.id));
-    }
-    logger.info(`[Scheduler] Scheduled ${job.jobName} with cron: ${job.cronExpression}${nextRun ? `, next run: ${nextRun.toISOString()}` : ''}`);
-}
-export async function executeJob(job) {
-    const db = await getDb();
-    const handler = jobHandlers.get(job.jobName);
-    if (!handler) {
-        logger.warn(`[Scheduler] No handler registered for job: ${job.jobName}`);
-        return;
-    }
-    const startedAt = new Date();
-    let status = 'success';
-    let error = null;
-    let recordsProcessed = 0;
-    let summary = {};
-    try {
-        logger.info(`[Scheduler] Executing job: ${job.jobName}`);
-        const result = await handler({
-            jobId: job.id,
-            jobName: job.jobName,
-            jobType: job.jobType,
-            config: job.jobConfig || {},
-            startedAt,
-        });
-        recordsProcessed = result.recordsProcessed;
-        summary = result.summary;
-        logger.info(`[Scheduler] Job ${job.jobName} completed: ${recordsProcessed} records processed`);
-    }
-    catch (err) {
-        status = 'failed';
-        error = err instanceof Error ? err.message : String(err);
-        logger.error(`[Scheduler] Job ${job.jobName} failed:`, error);
-    }
-    const completedAt = new Date();
-    if (db) {
-        const sqliteDb = db;
-        const [currentJob] = await sqliteDb
-            .select()
-            .from(maintenanceJobs)
-            .where(eq(maintenanceJobs.id, job.id));
-        await sqliteDb
-            .update(maintenanceJobs)
-            .set({
-            lastRunAt: startedAt,
-            lastRunStatus: status,
-            lastRunError: error,
-            lastRunDuration: completedAt.getTime() - startedAt.getTime(),
-            totalRuns: (currentJob?.totalRuns ?? 0) + 1,
-            successCount: status === 'success' ? (currentJob?.successCount ?? 0) + 1 : currentJob?.successCount,
-            failureCount: status === 'failed' ? (currentJob?.failureCount ?? 0) + 1 : currentJob?.failureCount,
-            nextRunAt: job.cronExpression ? getNextRunTime(job.cronExpression) : null,
-        })
-            .where(eq(maintenanceJobs.id, job.id));
-        await sqliteDb.insert(maintenanceJobHistory).values({
-            jobId: job.id,
-            startedAt,
-            completedAt,
-            duration: completedAt.getTime() - startedAt.getTime(),
-            status,
-            error,
-            recordsProcessed,
-            resultSummary: summary,
-        });
-    }
-}
-function getNextRunTime(cronExpression) {
-    try {
-        const now = new Date();
-        const parts = cronExpression.split(' ');
-        // Daily jobs: MM HH * * *
-        if (parts[2] === '*' && parts[3] === '*' && parts[4] === '*' && parts[1] !== '*') {
-            const next = new Date(now);
-            next.setHours(parseInt(parts[1]), parseInt(parts[0]), 0, 0);
-            if (next <= now)
-                next.setDate(next.getDate() + 1);
-            return next;
-        }
-        // Hourly jobs: MM * * * *
-        if (parts[1] === '*' && parts[2] === '*' && parts[3] === '*' && parts[4] === '*') {
-            const next = new Date(now);
-            next.setMinutes(parseInt(parts[0]), 0, 0);
-            if (next <= now)
-                next.setHours(next.getHours() + 1);
-            return next;
-        }
-        // Weekly jobs: MM HH * * D
-        if (parts[4] !== '*') {
-            const dayOfWeek = parseInt(parts[4]);
-            const next = new Date(now);
-            next.setHours(parseInt(parts[1]), parseInt(parts[0]), 0, 0);
-            const daysUntil = (dayOfWeek - next.getDay() + 7) % 7;
-            next.setDate(next.getDate() + (daysUntil === 0 && next > now ? 7 : daysUntil));
-            return next;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function getScheduledJobs() {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const sqliteDb = db;
-    const jobs = await sqliteDb.select().from(maintenanceJobs);
-    return jobs.map((job) => ({
-        id: job.id,
-        jobName: job.jobName,
-        jobType: job.jobType,
-        cronExpression: job.cronExpression || '',
-        enabled: job.enabled ?? true,
-        lastRunAt: job.lastRunAt ? new Date(job.lastRunAt) : null,
-        nextRunAt: job.nextRunAt ? new Date(job.nextRunAt) : null,
-        jobConfig: job.jobConfig || {},
-    }));
-}
-export async function getOverdueJobs() {
-    const db = await getDb();
-    if (!db)
-        return [];
-    const now = new Date();
-    const sqliteDb = db;
-    const jobs = await sqliteDb.select().from(maintenanceJobs);
-    return jobs
-        .filter((job) => {
-        if (!job.enabled)
-            return false;
-        if (!job.nextRunAt)
-            return true;
-        return new Date(job.nextRunAt) < now;
-    })
-        .map((job) => ({
-        id: job.id,
-        jobName: job.jobName,
-        jobType: job.jobType,
-        cronExpression: job.cronExpression || '',
-        enabled: job.enabled ?? true,
-        lastRunAt: job.lastRunAt ? new Date(job.lastRunAt) : null,
-        nextRunAt: job.nextRunAt ? new Date(job.nextRunAt) : null,
-        jobConfig: job.jobConfig || {},
-    }));
-}
-export function stopAllJobs() {
-    for (const [name, task] of activeTasks) {
-        task.stop();
-        logger.info(`[Scheduler] Stopped job: ${name}`);
-    }
-    activeTasks.clear();
-}
-//# sourceMappingURL=cron-scheduler.js.map

package/dist/core/scheduler/heartbeat.d.ts

@@ -1,11 +0,0 @@
-/** Heartbeat - Fallback job execution via heartbeat checking */
-export declare function heartbeat(): Promise<{
-    checked: boolean;
-    overdueCount: number;
-    executedJobs: string[];
-}>;
-export declare function startHeartbeatChecking(): void;
-export declare function stopHeartbeatChecking(): void;
-export declare function getLastHeartbeat(): Date | null;
-export declare function isHeartbeatDue(): boolean;
-//# sourceMappingURL=heartbeat.d.ts.map

package/dist/core/scheduler/heartbeat.js

@@ -1,73 +0,0 @@
-/** Heartbeat - Fallback job execution via heartbeat checking */
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-import { getOverdueJobs, executeJob } from './cron-scheduler.js';
-let lastHeartbeat = null;
-let heartbeatInterval = null;
-export async function heartbeat() {
-    const result = {
-        checked: false,
-        overdueCount: 0,
-        executedJobs: [],
-    };
-    if (config.schedulerMode === 'cron' && config.cronEnabled) {
-        logger.debug('[Heartbeat] Cron mode active, skipping heartbeat check');
-        return result;
-    }
-    lastHeartbeat = new Date();
-    result.checked = true;
-    try {
-        const overdueJobs = await getOverdueJobs();
-        result.overdueCount = overdueJobs.length;
-        if (overdueJobs.length === 0) {
-            logger.debug('[Heartbeat] No overdue jobs');
-            return result;
-        }
-        logger.info(`[Heartbeat] Found ${overdueJobs.length} overdue jobs, executing...`);
-        for (const job of overdueJobs) {
-            try {
-                await executeJob(job);
-                result.executedJobs.push(job.jobName);
-                logger.info(`[Heartbeat] Executed overdue job: ${job.jobName}`);
-            }
-            catch (error) {
-                logger.error(`[Heartbeat] Failed to execute job ${job.jobName}:`, error);
-            }
-        }
-        return result;
-    }
-    catch (error) {
-        logger.error('[Heartbeat] Failed to check overdue jobs:', error);
-        return result;
-    }
-}
-export function startHeartbeatChecking() {
-    if (config.schedulerMode === 'cron' && config.cronEnabled) {
-        logger.info('[Heartbeat] Cron mode active, heartbeat checking disabled');
-        return;
-    }
-    stopHeartbeatChecking();
-    heartbeatInterval = setInterval(async () => {
-        await heartbeat();
-    }, config.heartbeatInterval);
-    logger.info(`[Heartbeat] Started periodic checking (interval: ${config.heartbeatInterval}ms)`);
-    heartbeat().catch(err => {
-        logger.error('[Heartbeat] Initial heartbeat failed:', err);
-    });
-}
-export function stopHeartbeatChecking() {
-    if (heartbeatInterval) {
-        clearInterval(heartbeatInterval);
-        heartbeatInterval = null;
-        logger.info('[Heartbeat] Stopped periodic checking');
-    }
-}
-export function getLastHeartbeat() {
-    return lastHeartbeat;
-}
-export function isHeartbeatDue() {
-    if (!lastHeartbeat)
-        return true;
-    return Date.now() - lastHeartbeat.getTime() > config.heartbeatInterval;
-}
-//# sourceMappingURL=heartbeat.js.map

package/dist/core/scheduler/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Scheduler Module
- * Cron-based job scheduling with heartbeat fallback
- */
-export * from './cron-scheduler.js';
-export * from './heartbeat.js';
-export * from './job-runner.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/scheduler/job-runner.d.ts

@@ -1,11 +0,0 @@
-/** Job Runner - Maintenance job implementations */
-import { type JobExecutionContext } from './cron-scheduler.js';
-export declare function runNightlyJob(context: JobExecutionContext): Promise<{
-    recordsProcessed: number;
-    summary: Record<string, unknown>;
-}>;
-export declare function runWeeklyJob(context: JobExecutionContext): Promise<{
-    recordsProcessed: number;
-    summary: Record<string, unknown>;
-}>;
-//# sourceMappingURL=job-runner.d.ts.map

package/dist/core/scheduler/job-runner.js

@@ -1,164 +0,0 @@
-/** Job Runner - Maintenance job implementations */
-import { logger } from '../logger.js';
-import { runDeduplicationJob } from '../consolidation.js';
-import { runLifecycleMaintenance } from '../lifecycle.js';
-import { pruneWeakAssociations } from '../associations.js';
-import { pruneOldSummaries } from '../summarization.js';
-import { getDb } from '../../db/index.js';
-import { memories, memoryFeedback } from '../../db/drizzle/schema-sqlite.js';
-import { eq, and, gt, lt } from 'drizzle-orm';
-export async function runNightlyJob(context) {
-    const summary = {};
-    let recordsProcessed = 0;
-    logger.info('[NightlyJob] Starting nightly maintenance');
-    if (context.config.applyDecay !== false || context.config.updateTiers !== false) {
-        try {
-            const lifecycleResult = await runLifecycleMaintenance();
-            summary.decayApplied = lifecycleResult?.decayed || 0;
-            summary.tiersUpdated = (lifecycleResult?.tierChanges?.hot || 0) +
-                (lifecycleResult?.tierChanges?.warm || 0) +
-                (lifecycleResult?.tierChanges?.cold || 0);
-            recordsProcessed += summary.decayApplied;
-            recordsProcessed += summary.tiersUpdated;
-            logger.info(`[NightlyJob] Lifecycle: ${summary.decayApplied} decayed, ${summary.tiersUpdated} tier updates`);
-        }
-        catch (error) {
-            logger.error('[NightlyJob] Lifecycle maintenance failed:', error);
-            summary.lifecycleError = error instanceof Error ? error.message : String(error);
-        }
-    }
-    if (context.config.mergeDuplicates !== false) {
-        try {
-            const dedupResult = await runDeduplicationJob();
-            summary.duplicatesMerged = dedupResult?.mergedCount || 0;
-            recordsProcessed += summary.duplicatesMerged;
-            logger.info(`[NightlyJob] Merged ${summary.duplicatesMerged} duplicate memories`);
-        }
-        catch (error) {
-            logger.error('[NightlyJob] Deduplication failed:', error);
-            summary.dedupError = error instanceof Error ? error.message : String(error);
-        }
-    }
-    if (context.config.boostAccessed !== false) {
-        try {
-            const boostResult = await boostFrequentlyAccessed();
-            summary.memoriesBoosted = boostResult;
-            recordsProcessed += boostResult;
-            logger.info(`[NightlyJob] Boosted ${summary.memoriesBoosted} frequently accessed memories`);
-        }
-        catch (error) {
-            logger.error('[NightlyJob] Boost failed:', error);
-            summary.boostError = error instanceof Error ? error.message : String(error);
-        }
-    }
-    logger.info(`[NightlyJob] Completed: ${recordsProcessed} records processed`);
-    return { recordsProcessed, summary };
-}
-export async function runWeeklyJob(context) {
-    const summary = {};
-    let recordsProcessed = 0;
-    logger.info('[WeeklyJob] Starting weekly maintenance');
-    if (context.config.archiveStale !== false) {
-        try {
-            const archiveResult = await archiveStaleMemories(90);
-            summary.memoriesArchived = archiveResult;
-            recordsProcessed += archiveResult;
-            logger.info(`[WeeklyJob] Archived ${summary.memoriesArchived} stale memories`);
-        }
-        catch (error) {
-            logger.error('[WeeklyJob] Archive failed:', error);
-            summary.archiveError = error instanceof Error ? error.message : String(error);
-        }
-    }
-    if (context.config.pruneAssociations !== false) {
-        try {
-            const pruneResult = await pruneWeakAssociations();
-            summary.associationsPruned = typeof pruneResult === 'number' ? pruneResult : 0;
-            recordsProcessed += summary.associationsPruned;
-            logger.info(`[WeeklyJob] Pruned ${summary.associationsPruned} weak associations`);
-        }
-        catch (error) {
-            logger.error('[WeeklyJob] Association pruning failed:', error);
-            summary.pruneError = error instanceof Error ? error.message : String(error);
-        }
-    }
-    if (context.config.pruneSummaries !== false) {
-        try {
-            const summaryPruneResult = await pruneOldSummaries(30);
-            summary.summariesPruned = typeof summaryPruneResult === 'number' ? summaryPruneResult : 0;
-            recordsProcessed += summary.summariesPruned;
-            logger.info(`[WeeklyJob] Pruned ${summary.summariesPruned} old summaries`);
-        }
-        catch (error) {
-            logger.error('[WeeklyJob] Summary pruning failed:', error);
-            summary.summaryPruneError = error instanceof Error ? error.message : String(error);
-        }
-    }
-    if (context.config.cleanupFeedback !== false) {
-        try {
-            const feedbackCleanupResult = await cleanupOldFeedbackRecords(30);
-            summary.feedbackRecordsCleaned = feedbackCleanupResult;
-            recordsProcessed += feedbackCleanupResult;
-            logger.info(`[WeeklyJob] Cleaned ${summary.feedbackRecordsCleaned} old feedback records`);
-        }
-        catch (error) {
-            logger.error('[WeeklyJob] Feedback cleanup failed:', error);
-            summary.feedbackError = error instanceof Error ? error.message : String(error);
-        }
-    }
-    logger.info(`[WeeklyJob] Completed: ${recordsProcessed} records processed`);
-    return { recordsProcessed, summary };
-}
-async function boostFrequentlyAccessed() {
-    const db = await getDb();
-    if (!db)
-        return 0;
-    const sqliteDb = db;
-    const frequentlyAccessed = await sqliteDb
-        .select()
-        .from(memories)
-        .where(gt(memories.accessCount, 3));
-    let boosted = 0;
-    for (const memory of frequentlyAccessed) {
-        const currentPriority = memory.retrievalPriority ?? 50;
-        const newPriority = Math.min(100, currentPriority + 5);
-        await sqliteDb
-            .update(memories)
-            .set({ retrievalPriority: newPriority })
-            .where(eq(memories.id, memory.id));
-        boosted++;
-    }
-    return boosted;
-}
-async function archiveStaleMemories(daysOld) {
-    const db = await getDb();
-    if (!db)
-        return 0;
-    const staleThreshold = new Date(Date.now() - daysOld * 24 * 60 * 60 * 1000);
-    const sqliteDb = db;
-    const staleMemories = await sqliteDb
-        .select()
-        .from(memories)
-        .where(and(lt(memories.lastAccessedAt, staleThreshold), lt(memories.importanceScore, 30), eq(memories.isProtected, false), eq(memories.isPinned, false)));
-    let archived = 0;
-    for (const memory of staleMemories) {
-        await sqliteDb
-            .update(memories)
-            .set({ tier: 'cold' })
-            .where(eq(memories.id, memory.id));
-        archived++;
-    }
-    return archived;
-}
-async function cleanupOldFeedbackRecords(daysOld) {
-    const db = await getDb();
-    if (!db)
-        return 0;
-    const oldThreshold = new Date(Date.now() - daysOld * 24 * 60 * 60 * 1000);
-    const sqliteDb = db;
-    await sqliteDb
-        .delete(memoryFeedback)
-        .where(lt(memoryFeedback.createdAt, oldThreshold));
-    return 0;
-}
-//# sourceMappingURL=job-runner.js.map

package/dist/core/search/conversations.d.ts

@@ -1,25 +0,0 @@
-export interface ConversationRecord {
-    id: string;
-    projectId?: string | null;
-    sessionId: string;
-    title?: string | null;
-    summary?: string | null;
-    messageCount?: number | null;
-    tokenCount?: number | null;
-    startedAt?: string | null;
-    endedAt?: string | null;
-}
-export interface ConversationSearchInput {
-    query: string;
-    limit?: number;
-    role?: 'user' | 'assistant';
-}
-export interface RecentConversationsInput {
-    n?: number;
-    before?: string;
-    after?: string;
-    project?: string;
-}
-export declare function searchConversations(input: ConversationSearchInput): Promise<ConversationRecord[]>;
-export declare function getRecentConversations(input: RecentConversationsInput): Promise<ConversationRecord[]>;
-//# sourceMappingURL=conversations.d.ts.map