squish-memory 1.2.0 → 1.2.1

package/dist/core/memory/query-processor.d.ts

@@ -1,21 +0,0 @@
-/**
- * Query Processor - Phase 4
- * Expands queries for better retrieval coverage
- */
-export interface ProcessedQuery {
-    original: string;
-    expanded: string[];
-    entities: string[];
-    synonyms: Map<string, string[]>;
-}
-/**
- * Simple synonym expansion without LLM calls
- * Fast, deterministic, no API costs
- */
-export declare function expandQuery(query: string): ProcessedQuery;
-/**
- * Multi-query search combiner
- * Searches with multiple query variants and merges results
- */
-export declare function multiQuerySearch<T>(queries: string[], searchFn: (query: string) => Promise<T[]>, dedupeKey: (item: T) => string): Promise<T[]>;
-//# sourceMappingURL=query-processor.d.ts.map

package/dist/core/memory/query-processor.js

@@ -1,106 +0,0 @@
-/**
- * Query Processor - Phase 4
- * Expands queries for better retrieval coverage
- */
-/**
- * Simple synonym expansion without LLM calls
- * Fast, deterministic, no API costs
- */
-export function expandQuery(query) {
-    const synonyms = new Map();
-    // Define common synonym mappings
-    const synonymMap = {
-        'manager': ['manager', 'boss', 'supervisor', 'lead'],
-        'team': ['team', 'group', 'staff', 'crew'],
-        'project': ['project', 'initiative', 'endeavor', 'work'],
-        'start': ['start', 'begin', 'commence', 'initiate'],
-        'budget': ['budget', 'funding', 'cost', 'allocation'],
-        'language': ['language', 'tech', 'stack', 'technology'],
-        'feature': ['feature', 'capability', 'function', 'aspect'],
-        'based': ['based', 'located', 'situated', 'headquartered'],
-    };
-    const lowerQuery = query.toLowerCase();
-    // Find matching synonyms
-    for (const [key, values] of Object.entries(synonymMap)) {
-        if (lowerQuery.includes(key)) {
-            synonyms.set(key, values);
-        }
-    }
-    // Generate expanded queries by substituting synonyms
-    const expanded = [query]; // Original
-    // Add one variation per synonym found
-    for (const [term, variants] of synonyms) {
-        for (const variant of variants) {
-            if (variant !== term) {
-                expanded.push(query.replace(new RegExp(term, 'gi'), variant));
-            }
-        }
-    }
-    // Extract entities (capitalized words), filtering common stopwords
-    const STOP_WORDS = new Set([
-        'The', 'A', 'An', 'This', 'That', 'These', 'Those',
-        'I', 'You', 'We', 'They', 'He', 'She', 'It',
-        'What', 'When', 'Where', 'Why', 'How',
-        'My', 'Your', 'Our', 'Their', 'Its',
-        'If', 'But', 'Or', 'And', 'So', 'Then',
-        'Just', 'Only', 'Also', 'Very', 'Too',
-        'Has', 'Have', 'Had', 'Does', 'Did', 'Will', 'Would', 'Could', 'Should',
-        'Can', 'May', 'Might', 'Must', 'Shall',
-        'With', 'Without', 'From', 'Into', 'About', 'After', 'Before', 'Between',
-        'During', 'Through', 'Under', 'Over', 'Above', 'Below',
-        'All', 'Some', 'Any', 'No', 'Not', 'Each', 'Every', 'Most', 'Many', 'Much',
-        'Few', 'Both', 'Either', 'Neither', 'Another', 'Other',
-        'Such', 'Same', 'Different', 'New', 'Old', 'First', 'Last', 'Next', 'Last',
-        'See', 'Get', 'Make', 'Do', 'Say', 'Tell', 'Know', 'Think', 'Want', 'Use',
-        'Find', 'Give', 'Take', 'Show', 'Send', 'Put', 'Keep', 'Let', 'Begin', 'Seem',
-    ]);
-    // Common tech stack terms that ARE entities (preserves known entities)
-    const TECH_TERMS = new Set([
-        'TypeScript', 'JavaScript', 'Python', 'Java', 'Go', 'Rust', 'Ruby', 'PHP',
-        'React', 'Vue', 'Angular', 'Svelte', 'Next', 'Nuxt', 'Astro',
-        'Node', 'Express', 'Fastify', 'Deno', 'Bun',
-        'PostgreSQL', 'MySQL', 'MongoDB', 'Redis', 'SQLite', 'DynamoDB',
-        'AWS', 'GCP', 'Azure', 'Docker', 'Kubernetes', 'Terraform',
-        'OpenAI', 'Anthropic', 'Google', 'Meta', 'Microsoft', 'Apple',
-        'HTML', 'CSS', 'Tailwind', 'GraphQL', 'REST', 'gRPC', 'WebSocket',
-        'CI', 'CD', 'Git', 'GitHub', 'GitLab', 'Bitbucket',
-    ]);
-    const entityMatches = query.match(/\b[A-Z][a-z]{2,}\b/g) || [];
-    const entities = [...new Set(entityMatches)].filter(e => {
-        // Always include known tech terms
-        if (TECH_TERMS.has(e))
-            return true;
-        // Filter out stopwords
-        return !STOP_WORDS.has(e);
-    });
-    return {
-        original: query,
-        expanded: [...new Set(expanded)], // Deduplicate
-        entities,
-        synonyms,
-    };
-}
-/**
- * Multi-query search combiner
- * Searches with multiple query variants and merges results
- */
-export async function multiQuerySearch(queries, searchFn, dedupeKey) {
-    const allResults = [];
-    // Search with each query variant
-    for (const query of queries) {
-        const results = await searchFn(query);
-        allResults.push(...results);
-    }
-    // Deduplicate by key
-    const seen = new Set();
-    const unique = [];
-    for (const item of allResults) {
-        const key = dedupeKey(item);
-        if (!seen.has(key)) {
-            seen.add(key);
-            unique.push(item);
-        }
-    }
-    return unique;
-}
-//# sourceMappingURL=query-processor.js.map

package/dist/core/memory/query-rewriter.d.ts

@@ -1,13 +0,0 @@
-/** Query Rewriter - Rewrite user queries for better retrieval using LLM */
-import { type ContextMessage } from './context-collector.js';
-export interface RewriteResult {
-    original: string;
-    rewritten: string;
-    expansions: string[];
-    intent: 'search' | 'recall' | 'question' | 'context';
-    confidence: number;
-    method: 'llm' | 'synonym' | 'none';
-}
-export declare function rewriteQuery(query: string, context: ContextMessage[]): Promise<RewriteResult>;
-export declare function wouldBenefitFromRewrite(query: string): boolean;
-//# sourceMappingURL=query-rewriter.d.ts.map

package/dist/core/memory/query-rewriter.js

@@ -1,118 +0,0 @@
-/** Query Rewriter - Rewrite user queries for better retrieval using LLM */
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-import { expandQuery } from './query-processor.js';
-const REWRITE_SYSTEM_PROMPT = `You are a search query optimizer. Given a conversation context and a user's latest message, rewrite the message into the single most effective search query to retrieve relevant memories.
-
-Rules:
-1. Output ONLY the optimized search query - no explanations or extra text
-2. Remove filler words (please, can you, etc.)
-3. Focus on the core information need
-4. Preserve important entities (names, dates, technical terms)
-5. Add synonyms for key terms if helpful
-6. Consider what memories would be most relevant
-7. If the message is about recalling something specific, include those details`;
-export async function rewriteQuery(query, context) {
-    if (!config.queryRewritingEnabled) {
-        return {
-            original: query,
-            rewritten: query,
-            expansions: [],
-            intent: detectIntent(query),
-            confidence: 1.0,
-            method: 'none',
-        };
-    }
-    if (config.queryRewritingFallbackEnabled) {
-        try {
-            const llmResult = await rewriteWithLLM(query, context);
-            if (llmResult)
-                return llmResult;
-        }
-        catch (error) {
-            logger.warn(`[QueryRewriter] LLM rewrite failed, falling back to synonym: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    if (config.queryRewritingFallbackEnabled) {
-        const expanded = expandQuery(query);
-        return {
-            original: query,
-            rewritten: expanded.expanded[0] || query,
-            expansions: expanded.expanded.slice(1),
-            intent: detectIntent(query),
-            confidence: 0.7,
-            method: 'synonym',
-        };
-    }
-    return {
-        original: query,
-        rewritten: query,
-        expansions: [],
-        intent: detectIntent(query),
-        confidence: 1.0,
-        method: 'none',
-    };
-}
-async function rewriteWithLLM(query, context) {
-    if (context.length < 2)
-        return null;
-    const lastUserMsg = context.filter(m => m.role === 'user').pop()?.content || '';
-    const pronounPattern = /\b(it|that|this|they|them|those|these|he|she|his|her)\b/i;
-    const hasPronouns = pronounPattern.test(query);
-    const vaguePattern = /\b(the thing|the stuff|what (we|I) (talked|discussed|mentioned))\b/i;
-    const hasVagueRef = vaguePattern.test(query);
-    if (!hasPronouns && !hasVagueRef)
-        return null;
-    let rewritten = query;
-    const entityPattern = /\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g;
-    const contextEntities = lastUserMsg.match(entityPattern) || [];
-    const techPattern = /\b([a-z]+\.(?:ts|js|py|json|md)|@[a-z]+\/[a-z]+|\b[A-Z]{2,}\b)\b/gi;
-    const techTerms = lastUserMsg.match(techPattern) || [];
-    if (contextEntities.length > 0 && hasPronouns) {
-        const mostLikelyEntity = contextEntities[contextEntities.length - 1];
-        if (!query.toLowerCase().includes(mostLikelyEntity.toLowerCase())) {
-            rewritten = `${query} ${mostLikelyEntity}`;
-        }
-    }
-    const firstTechTerm = techTerms[0];
-    if (firstTechTerm && !query.includes(firstTechTerm)) {
-        rewritten = `${rewritten} ${firstTechTerm}`;
-    }
-    if (rewritten !== query) {
-        logger.info(`[QueryRewriter] Rewrote "${query}" -> "${rewritten}"`);
-        return {
-            original: query,
-            rewritten,
-            expansions: [],
-            intent: detectIntent(query),
-            confidence: 0.8,
-            method: 'llm',
-        };
-    }
-    return null;
-}
-function detectIntent(query) {
-    const lower = query.toLowerCase();
-    if (/\b(remember|recall|what did (we|I)|what was|retrieve)\b/.test(lower)) {
-        return 'recall';
-    }
-    if (/^(what|who|when|where|why|how|which|is|are|can|do|does)/.test(lower)) {
-        return 'question';
-    }
-    if (/\b(context|background|about|regarding|concerning)\b/.test(lower)) {
-        return 'context';
-    }
-    return 'search';
-}
-export function wouldBenefitFromRewrite(query) {
-    if (query.split(/\s+/).length < 3)
-        return true;
-    const pronounPattern = /\b(it|that|this|they|them|those|these|he|she|his|her)\b/i;
-    if (pronounPattern.test(query))
-        return true;
-    const vaguePattern = /\b(the thing|the stuff|what (we|I) (talked|discussed|mentioned))\b/i;
-    if (vaguePattern.test(query))
-        return true;
-    return false;
-}
-//# sourceMappingURL=query-rewriter.js.map

package/dist/core/memory/response-analyzer.d.ts

@@ -1,9 +0,0 @@
-/** Response Analyzer - Analyze LLM responses for memory references (Echo/Fizzle tracking) */
-export interface AnalysisResult {
-    referencedMemoryIds: string[];
-    referenceCount: number;
-    hasReferences: boolean;
-}
-export declare function analyzeResponseForMemoryReferences(responseText: string, injectedMemoryIds: string[], injectedMemoryContent: Map<string, string>): AnalysisResult;
-export declare function mightContainMemoryReferences(responseText: string): boolean;
-//# sourceMappingURL=response-analyzer.d.ts.map

package/dist/core/memory/response-analyzer.js

@@ -1,61 +0,0 @@
-/** Response Analyzer - Analyze LLM responses for memory references (Echo/Fizzle tracking) */
-import { logger } from '../logger.js';
-const REFERENCE_PATTERNS = [
-    /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/gi,
-    /as (?:i |we )?(?:mentioned|noted|remembered|recalled|stored|saved)/gi,
-    /(?:based|drawing) on (?:my|our|the) (?:memory|previous|earlier)/gi,
-    /(?:i |we )?(?:recall|remember|noted) (?:that |earlier )?/gi,
-    /from (?:my|our|the) (?:memory|notes|records)/gi,
-];
-export function analyzeResponseForMemoryReferences(responseText, injectedMemoryIds, injectedMemoryContent) {
-    const referencedMemoryIds = [];
-    const responseLower = responseText.toLowerCase();
-    for (const memoryId of injectedMemoryIds) {
-        if (responseText.includes(memoryId)) {
-            referencedMemoryIds.push(memoryId);
-            logger.debug(`[ResponseAnalyzer] Direct reference found: ${memoryId}`);
-        }
-    }
-    for (const [memoryId, content] of injectedMemoryContent) {
-        if (referencedMemoryIds.includes(memoryId))
-            continue;
-        const contentWords = content.toLowerCase().split(/\s+/).filter(w => w.length > 3);
-        if (contentWords.length < 5)
-            continue;
-        let matchCount = 0;
-        for (const word of contentWords) {
-            if (responseLower.includes(word)) {
-                matchCount++;
-            }
-        }
-        const matchRatio = matchCount / contentWords.length;
-        if (matchRatio > 0.5) {
-            referencedMemoryIds.push(memoryId);
-            logger.debug(`[ResponseAnalyzer] Content match (${(matchRatio * 100).toFixed(0)}%): ${memoryId}`);
-        }
-    }
-    for (const pattern of REFERENCE_PATTERNS) {
-        const matches = responseText.match(pattern);
-        if (matches && matches.length > 0) {
-            logger.debug(`[ResponseAnalyzer] Reference pattern found: ${matches.length} matches`);
-        }
-    }
-    const result = {
-        referencedMemoryIds: [...new Set(referencedMemoryIds)],
-        referenceCount: referencedMemoryIds.length,
-        hasReferences: referencedMemoryIds.length > 0,
-    };
-    if (result.hasReferences) {
-        logger.info(`[ResponseAnalyzer] Found ${result.referenceCount} memory references`);
-    }
-    return result;
-}
-export function mightContainMemoryReferences(responseText) {
-    const responseLower = responseText.toLowerCase();
-    const quickPatterns = [
-        'remember', 'recall', 'mentioned', 'noted', 'earlier',
-        'previous', 'as i', 'as we', 'from my', 'from our',
-    ];
-    return quickPatterns.some(pattern => responseLower.includes(pattern));
-}
-//# sourceMappingURL=response-analyzer.js.map

package/dist/core/memory/retrieval-feedback.d.ts

@@ -1,70 +0,0 @@
-/**
- * Retrieval Feedback System
- *
- * Tracks whether retrieved memories were useful in responses.
- * Strengthens useful paths, prunes stale nodes, tunes edge weights.
- */
-export interface RetrievalFeedback {
-    memoryId: string;
-    query: string;
-    wasUseful: boolean;
-    cited: boolean;
-    responseId?: string;
-    timestamp: Date;
-}
-export interface FeedbackStats {
-    totalRetrievals: number;
-    usefulRetrievals: number;
-    citedRetrievals: number;
-    usefulnessRate: number;
-    citationRate: number;
-}
-/**
- * Record that a memory was retrieved for a query.
- * Call this when a memory appears in search results.
- */
-export declare function recordRetrieval(memoryId: string, query: string, options?: {
-    sessionId?: string;
-}): void;
-/**
- * Record that a retrieved memory was actually useful.
- * Call this when a memory is cited or referenced in a response.
- */
-export declare function recordUsefulRetrieval(memoryId: string, query: string, options?: {
-    cited?: boolean;
-    responseId?: string;
-    sessionId?: string;
-}): void;
-/**
- * Record that a memory was cited in a response.
- * This is stronger feedback than just "useful" - it means the memory
- * was explicitly referenced.
- */
-export declare function recordCitation(memoryId: string, responseId: string, options?: {
-    sessionId?: string;
-}): void;
-/**
- * Get feedback statistics for a specific memory.
- */
-export declare function getRetrievalStats(memoryId: string): FeedbackStats;
-/**
- * Get overall feedback statistics.
- */
-export declare function getOverallFeedbackStats(): FeedbackStats;
-/**
- * Flush feedback to the database, updating association weights.
- */
-export declare function flushFeedback(): Promise<{
-    strengthened: number;
-    weakened: number;
-    total: number;
-}>;
-/**
- * Start the periodic feedback flush timer.
- */
-export declare function startFeedbackFlushTimer(): void;
-/**
- * Stop the periodic feedback flush timer.
- */
-export declare function stopFeedbackFlushTimer(): void;
-//# sourceMappingURL=retrieval-feedback.d.ts.map

package/dist/core/memory/retrieval-feedback.js

@@ -1,213 +0,0 @@
-/**
- * Retrieval Feedback System
- *
- * Tracks whether retrieved memories were useful in responses.
- * Strengthens useful paths, prunes stale nodes, tunes edge weights.
- */
-import { eq, sql } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-// ─── In-Memory Feedback Buffer ───────────────────────────────────────────────
-const feedbackBuffer = new Map();
-const MAX_BUFFER_SIZE = 1000;
-const FLUSH_INTERVAL_MS = 60000; // 1 minute
-let flushTimer = null;
-/**
- * Record that a memory was retrieved for a query.
- * Call this when a memory appears in search results.
- */
-export function recordRetrieval(memoryId, query, options) {
-    const key = options?.sessionId || 'default';
-    const buffer = feedbackBuffer.get(key) || [];
-    buffer.push({
-        memoryId,
-        query,
-        wasUseful: false, // Will be updated later
-        cited: false,
-        timestamp: new Date(),
-    });
-    // Trim buffer if too large
-    if (buffer.length > MAX_BUFFER_SIZE) {
-        buffer.splice(0, buffer.length - MAX_BUFFER_SIZE);
-    }
-    feedbackBuffer.set(key, buffer);
-}
-/**
- * Record that a retrieved memory was actually useful.
- * Call this when a memory is cited or referenced in a response.
- */
-export function recordUsefulRetrieval(memoryId, query, options) {
-    const key = options?.sessionId || 'default';
-    const buffer = feedbackBuffer.get(key) || [];
-    // Find the existing retrieval record and update it
-    const existing = buffer.find(f => f.memoryId === memoryId && f.query === query && !f.wasUseful);
-    if (existing) {
-        existing.wasUseful = true;
-        existing.cited = options?.cited ?? false;
-        existing.responseId = options?.responseId;
-    }
-    else {
-        // Add a new record
-        buffer.push({
-            memoryId,
-            query,
-            wasUseful: true,
-            cited: options?.cited ?? false,
-            responseId: options?.responseId,
-            timestamp: new Date(),
-        });
-    }
-    feedbackBuffer.set(key, buffer);
-}
-/**
- * Record that a memory was cited in a response.
- * This is stronger feedback than just "useful" - it means the memory
- * was explicitly referenced.
- */
-export function recordCitation(memoryId, responseId, options) {
-    const key = options?.sessionId || 'default';
-    const buffer = feedbackBuffer.get(key) || [];
-    // Mark all retrievals of this memory as useful
-    for (const feedback of buffer) {
-        if (feedback.memoryId === memoryId) {
-            feedback.wasUseful = true;
-            feedback.cited = true;
-            feedback.responseId = responseId;
-        }
-    }
-    feedbackBuffer.set(key, buffer);
-}
-/**
- * Get feedback statistics for a specific memory.
- */
-export function getRetrievalStats(memoryId) {
-    let totalRetrievals = 0;
-    let usefulRetrievals = 0;
-    let citedRetrievals = 0;
-    for (const [, buffer] of feedbackBuffer) {
-        for (const feedback of buffer) {
-            if (feedback.memoryId === memoryId) {
-                totalRetrievals++;
-                if (feedback.wasUseful)
-                    usefulRetrievals++;
-                if (feedback.cited)
-                    citedRetrievals++;
-            }
-        }
-    }
-    return {
-        totalRetrievals,
-        usefulRetrievals,
-        citedRetrievals,
-        usefulnessRate: totalRetrievals > 0 ? usefulRetrievals / totalRetrievals : 0,
-        citationRate: totalRetrievals > 0 ? citedRetrievals / totalRetrievals : 0,
-    };
-}
-/**
- * Get overall feedback statistics.
- */
-export function getOverallFeedbackStats() {
-    let totalRetrievals = 0;
-    let usefulRetrievals = 0;
-    let citedRetrievals = 0;
-    for (const [, buffer] of feedbackBuffer) {
-        for (const feedback of buffer) {
-            totalRetrievals++;
-            if (feedback.wasUseful)
-                usefulRetrievals++;
-            if (feedback.cited)
-                citedRetrievals++;
-        }
-    }
-    return {
-        totalRetrievals,
-        usefulRetrievals,
-        citedRetrievals,
-        usefulnessRate: totalRetrievals > 0 ? usefulRetrievals / totalRetrievals : 0,
-        citationRate: totalRetrievals > 0 ? citedRetrievals / totalRetrievals : 0,
-    };
-}
-/**
- * Flush feedback to the database, updating association weights.
- */
-export async function flushFeedback() {
-    const db = await getDb();
-    const schema = await getSchema();
-    let strengthened = 0;
-    let weakened = 0;
-    let total = 0;
-    for (const [, buffer] of feedbackBuffer) {
-        for (const feedback of buffer) {
-            total++;
-            try {
-                // Get associations involving this memory
-                const associations = await db
-                    .select()
-                    .from(schema.memoryAssociations)
-                    .where(sql `${schema.memoryAssociations.fromMemoryId} = ${feedback.memoryId} OR ${schema.memoryAssociations.toMemoryId} = ${feedback.memoryId}`);
-                for (const assoc of associations) {
-                    if (feedback.wasUseful) {
-                        // Strengthen: increase weight and coactivation count
-                        await db
-                            .update(schema.memoryAssociations)
-                            .set({
-                            weight: sql `${schema.memoryAssociations.weight} + 1`,
-                            coactivationCount: sql `${schema.memoryAssociations.coactivationCount} + 1`,
-                            lastCoactivatedAt: new Date(),
-                        })
-                            .where(eq(schema.memoryAssociations.id, assoc.id));
-                        strengthened++;
-                    }
-                    else {
-                        // Weaken: decrease weight slightly (but don't go below 1)
-                        await db
-                            .update(schema.memoryAssociations)
-                            .set({
-                            weight: sql `GREATEST(${schema.memoryAssociations.weight} - 0.5, 1)`,
-                        })
-                            .where(eq(schema.memoryAssociations.id, assoc.id));
-                        weakened++;
-                    }
-                }
-            }
-            catch (error) {
-                logger.debug('Error updating association weights', {
-                    memoryId: feedback.memoryId,
-                    error: error,
-                });
-            }
-        }
-    }
-    // Clear the buffer after flushing
-    feedbackBuffer.clear();
-    logger.info('Feedback flushed', { strengthened, weakened, total });
-    return { strengthened, weakened, total };
-}
-/**
- * Start the periodic feedback flush timer.
- */
-export function startFeedbackFlushTimer() {
-    if (flushTimer)
-        return;
-    flushTimer = setInterval(async () => {
-        try {
-            await flushFeedback();
-        }
-        catch (error) {
-            logger.error('Error flushing feedback', { error: error });
-        }
-    }, FLUSH_INTERVAL_MS);
-    logger.info('Feedback flush timer started', { intervalMs: FLUSH_INTERVAL_MS });
-}
-/**
- * Stop the periodic feedback flush timer.
- */
-export function stopFeedbackFlushTimer() {
-    if (flushTimer) {
-        clearInterval(flushTimer);
-        flushTimer = null;
-        logger.info('Feedback flush timer stopped');
-    }
-}
-//# sourceMappingURL=retrieval-feedback.js.map

package/dist/core/memory/serialization.d.ts

@@ -1,10 +0,0 @@
-export declare function normalizeTags(tags?: string[]): string[];
-export declare function toSqliteJson(value: unknown): string | null;
-export declare function fromSqliteJson<T>(value: string | null | undefined): T | null;
-export declare function toSqliteTags(tags?: string[]): string | null;
-export declare function fromSqliteTags(value: string | null | undefined): string[];
-export declare function serializeTags(tags?: string[]): string[] | string | null | undefined;
-export declare function deserializeTags(value: string[] | string | null | undefined): string[];
-export declare function serializeMetadata(metadata: Record<string, unknown> | null | undefined): Record<string, unknown> | string | null;
-export declare function deserializeMetadata(value: Record<string, unknown> | string | null | undefined): Record<string, unknown> | null;
-//# sourceMappingURL=serialization.d.ts.map