opencode-lcm 0.11.0

package/dist/preview-providers.js

@@ -0,0 +1,246 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { getLogger } from './logging.js';
+import { resolveWorkspacePath } from './workspace-path.js';
+function inferLocalPath(workspaceDirectory, file) {
+    const sourcePath = file.source && 'path' in file.source ? file.source.path : undefined;
+    if (!sourcePath)
+        return undefined;
+    try {
+        return resolveWorkspacePath(workspaceDirectory, sourcePath);
+    }
+    catch (error) {
+        getLogger().debug('Failed to resolve workspace path', { sourcePath, error });
+        return undefined;
+    }
+}
+function toHexPreview(buffer, bytes) {
+    if (buffer.length === 0)
+        return undefined;
+    return [...buffer.subarray(0, Math.max(1, bytes))]
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join(' ');
+}
+function parsePngDimensions(buffer) {
+    if (buffer.length < 24)
+        return undefined;
+    if (!buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+        return undefined;
+    return {
+        width: buffer.readUInt32BE(16),
+        height: buffer.readUInt32BE(20),
+    };
+}
+function parseGifDimensions(buffer) {
+    if (buffer.length < 10)
+        return undefined;
+    const header = buffer.subarray(0, 6).toString('ascii');
+    if (header !== 'GIF87a' && header !== 'GIF89a')
+        return undefined;
+    return {
+        width: buffer.readUInt16LE(6),
+        height: buffer.readUInt16LE(8),
+    };
+}
+function parseJpegDimensions(buffer) {
+    if (buffer.length < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8)
+        return undefined;
+    let offset = 2;
+    while (offset + 9 < buffer.length) {
+        if (buffer[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+        const marker = buffer[offset + 1];
+        if (marker === 0xd9 || marker === 0xda)
+            break;
+        const size = buffer.readUInt16BE(offset + 2);
+        if (size < 2 || offset + 2 + size > buffer.length)
+            break;
+        if ((marker >= 0xc0 && marker <= 0xc3) ||
+            (marker >= 0xc5 && marker <= 0xc7) ||
+            (marker >= 0xc9 && marker <= 0xcb) ||
+            (marker >= 0xcd && marker <= 0xcf)) {
+            return {
+                height: buffer.readUInt16BE(offset + 5),
+                width: buffer.readUInt16BE(offset + 7),
+            };
+        }
+        offset += 2 + size;
+    }
+    return undefined;
+}
+function estimatePdfPages(buffer) {
+    const text = buffer.toString('latin1');
+    const matches = text.match(/\/Type\s*\/Page([^s]|$)/g);
+    return matches && matches.length > 0 ? matches.length : undefined;
+}
+function estimateZipEntries(buffer) {
+    if (buffer.length < 4)
+        return undefined;
+    const localFileHeaderSignature = 0x04034b50;
+    const endOfCentralDirectorySignature = 0x06054b50;
+    const firstSignature = buffer.readUInt32LE(0);
+    if (firstSignature !== localFileHeaderSignature &&
+        firstSignature !== endOfCentralDirectorySignature) {
+        return undefined;
+    }
+    const searchStart = Math.max(0, buffer.length - 65557);
+    for (let offset = buffer.length - 22; offset >= searchStart; offset -= 1) {
+        if (buffer.readUInt32LE(offset) !== endOfCentralDirectorySignature)
+            continue;
+        return buffer.readUInt16LE(offset + 10);
+    }
+    let entries = 0;
+    for (let offset = 0; offset <= buffer.length - 4; offset += 1) {
+        if (buffer.readUInt32LE(offset) === localFileHeaderSignature)
+            entries += 1;
+    }
+    return entries > 0 ? entries : undefined;
+}
+const fingerprintProvider = {
+    name: 'fingerprint',
+    apply(_context, helpers) {
+        const filePath = helpers.resolvePath();
+        const bytes = helpers.readBytes();
+        if (!filePath || !bytes)
+            return { metadata: {}, lines: [], summaryBits: [] };
+        const sha256 = createHash('sha256').update(bytes).digest('hex');
+        const sizeBytes = bytes.length;
+        return {
+            metadata: {
+                previewLocalPath: filePath,
+                previewSha256: sha256,
+                previewSizeBytes: sizeBytes,
+            },
+            lines: [`Fingerprint: sha256 ${sha256} (${sizeBytes} bytes)`],
+            summaryBits: [`sha256 ${sha256.slice(0, 12)}`, `${sizeBytes} bytes`],
+        };
+    },
+};
+const bytePeekProvider = {
+    name: 'byte-peek',
+    apply(context, helpers) {
+        const bytes = helpers.readBytes();
+        const preview = bytes ? toHexPreview(bytes, context.bytePeek) : undefined;
+        if (!preview)
+            return { metadata: {}, lines: [], summaryBits: [] };
+        return {
+            metadata: {
+                previewBytePeekHex: preview,
+            },
+            lines: [`Byte peek: ${preview}`],
+            summaryBits: [`peek ${preview}`],
+        };
+    },
+};
+const imageDimensionsProvider = {
+    name: 'image-dimensions',
+    apply(context, helpers) {
+        if (context.category !== 'image')
+            return { metadata: {}, lines: [], summaryBits: [] };
+        const bytes = helpers.readBytes();
+        if (!bytes)
+            return { metadata: {}, lines: [], summaryBits: [] };
+        const dimensions = parsePngDimensions(bytes) ?? parseGifDimensions(bytes) ?? parseJpegDimensions(bytes);
+        if (!dimensions)
+            return { metadata: {}, lines: [], summaryBits: [] };
+        return {
+            metadata: {
+                previewImageWidth: dimensions.width,
+                previewImageHeight: dimensions.height,
+            },
+            lines: [`Image dimensions: ${dimensions.width}x${dimensions.height}`],
+            summaryBits: [`${dimensions.width}x${dimensions.height}`],
+        };
+    },
+};
+const pdfMetadataProvider = {
+    name: 'pdf-metadata',
+    apply(context, helpers) {
+        if (context.category !== 'pdf')
+            return { metadata: {}, lines: [], summaryBits: [] };
+        const bytes = helpers.readBytes();
+        if (!bytes)
+            return { metadata: {}, lines: [], summaryBits: [] };
+        const pageEstimate = estimatePdfPages(bytes);
+        if (!pageEstimate)
+            return { metadata: {}, lines: [], summaryBits: [] };
+        return {
+            metadata: {
+                previewPdfPageEstimate: pageEstimate,
+            },
+            lines: [`PDF page estimate: ${pageEstimate}`],
+            summaryBits: [`${pageEstimate} page${pageEstimate === 1 ? '' : 's'}`],
+        };
+    },
+};
+const zipMetadataProvider = {
+    name: 'zip-metadata',
+    apply(_context, helpers) {
+        const bytes = helpers.readBytes();
+        if (!bytes)
+            return { metadata: {}, lines: [], summaryBits: [] };
+        const entryCount = estimateZipEntries(bytes);
+        if (entryCount === undefined)
+            return { metadata: {}, lines: [], summaryBits: [] };
+        return {
+            metadata: {
+                previewZipEntryCount: entryCount,
+            },
+            lines: [`ZIP entries: ${entryCount}`],
+            summaryBits: [`${entryCount} entr${entryCount === 1 ? 'y' : 'ies'}`],
+        };
+    },
+};
+const PROVIDERS = [
+    fingerprintProvider,
+    bytePeekProvider,
+    imageDimensionsProvider,
+    pdfMetadataProvider,
+    zipMetadataProvider,
+];
+export async function runBinaryPreviewProviders(context) {
+    const localPath = inferLocalPath(context.workspaceDirectory, context.file);
+    let resolvedPath;
+    let resolvedBytes;
+    if (localPath) {
+        try {
+            resolvedBytes = await readFile(localPath);
+            resolvedPath = localPath;
+        }
+        catch (error) {
+            getLogger().debug('Failed to read file bytes for preview', { filePath: localPath, error });
+        }
+    }
+    const helpers = {
+        resolvePath() {
+            return resolvedPath;
+        },
+        readBytes() {
+            return resolvedBytes;
+        },
+    };
+    const enabled = new Set(context.enabledProviders);
+    const outputs = PROVIDERS.filter((provider) => enabled.has(provider.name)).map((provider) => ({
+        name: provider.name,
+        output: provider.apply(context, helpers),
+    }));
+    const metadata = {
+        previewProviders: outputs
+            .filter((entry) => Object.keys(entry.output.metadata).length > 0 || entry.output.lines.length > 0)
+            .map((entry) => entry.name),
+    };
+    const lines = [];
+    const summaryBits = [];
+    for (const entry of outputs) {
+        Object.assign(metadata, entry.output.metadata);
+        lines.push(...entry.output.lines);
+        summaryBits.push(...entry.output.summaryBits);
+    }
+    return {
+        metadata,
+        lines,
+        summaryBits,
+    };
+}

package/dist/privacy.d.ts

@@ -0,0 +1,16 @@
+import type { PrivacyOptions } from './types.js';
+export declare const PRIVACY_REDACTION_TEXT = "[REDACTED]";
+export declare const PRIVACY_REDACTED_PATH_TEXT = "[REDACTED_PATH]";
+export declare const PRIVACY_EXCLUDED_TOOL_OUTPUT = "[Excluded tool payload by opencode-lcm privacy policy.]";
+export declare const PRIVACY_EXCLUDED_FILE_CONTENT = "[Excluded file content by opencode-lcm privacy policy.]";
+export declare const PRIVACY_EXCLUDED_FILE_REFERENCE = "[Excluded file reference by opencode-lcm privacy policy.]";
+export type CompiledPrivacyOptions = {
+    excludeToolPrefixes: string[];
+    excludePathPatterns: RegExp[];
+    redactPatterns: RegExp[];
+};
+export declare function compilePrivacyOptions(options: PrivacyOptions): CompiledPrivacyOptions;
+export declare function redactText(value: string, privacy: CompiledPrivacyOptions): string;
+export declare function redactStructuredValue<T>(value: T, privacy: CompiledPrivacyOptions, currentKey?: string): T;
+export declare function isExcludedTool(toolName: string, privacy: CompiledPrivacyOptions): boolean;
+export declare function matchesExcludedPath(candidates: Array<string | undefined>, privacy: CompiledPrivacyOptions): boolean;

package/dist/privacy.js

@@ -0,0 +1,92 @@
+export const PRIVACY_REDACTION_TEXT = '[REDACTED]';
+export const PRIVACY_REDACTED_PATH_TEXT = '[REDACTED_PATH]';
+export const PRIVACY_EXCLUDED_TOOL_OUTPUT = '[Excluded tool payload by opencode-lcm privacy policy.]';
+export const PRIVACY_EXCLUDED_FILE_CONTENT = '[Excluded file content by opencode-lcm privacy policy.]';
+export const PRIVACY_EXCLUDED_FILE_REFERENCE = '[Excluded file reference by opencode-lcm privacy policy.]';
+const EXEMPT_STRING_KEYS = new Set([
+    'agent',
+    'artifactID',
+    'callID',
+    'fieldName',
+    'id',
+    'messageID',
+    'mime',
+    'modelID',
+    'name',
+    'nodeID',
+    'parentID',
+    'parentSessionID',
+    'partID',
+    'projectID',
+    'providerID',
+    'role',
+    'rootSessionID',
+    'sessionID',
+    'status',
+    'tool',
+    'type',
+    'urlScheme',
+]);
+function compilePattern(source) {
+    try {
+        const probe = new RegExp(source, 'u');
+        if (probe.test(''))
+            return undefined;
+        return new RegExp(source, 'gu');
+    }
+    catch {
+        return undefined;
+    }
+}
+function applyPatterns(value, patterns, replacement) {
+    let next = value;
+    for (const pattern of patterns) {
+        pattern.lastIndex = 0;
+        next = next.replace(pattern, replacement);
+    }
+    return next;
+}
+function matchesPattern(value, pattern) {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+}
+export function compilePrivacyOptions(options) {
+    return {
+        excludeToolPrefixes: [
+            ...new Set(options.excludeToolPrefixes.filter((value) => value.length > 0)),
+        ],
+        excludePathPatterns: options.excludePathPatterns
+            .map((source) => compilePattern(source))
+            .filter((pattern) => Boolean(pattern)),
+        redactPatterns: options.redactPatterns
+            .map((source) => compilePattern(source))
+            .filter((pattern) => Boolean(pattern)),
+    };
+}
+export function redactText(value, privacy) {
+    const redacted = applyPatterns(value, privacy.redactPatterns, PRIVACY_REDACTION_TEXT);
+    return applyPatterns(redacted, privacy.excludePathPatterns, PRIVACY_REDACTED_PATH_TEXT);
+}
+export function redactStructuredValue(value, privacy, currentKey) {
+    if (typeof value === 'string') {
+        return (currentKey && EXEMPT_STRING_KEYS.has(currentKey) ? value : redactText(value, privacy));
+    }
+    if (!value || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value)) {
+        return value.map((entry) => redactStructuredValue(entry, privacy, currentKey));
+    }
+    const entries = Object.entries(value).map(([key, entry]) => [
+        key,
+        redactStructuredValue(entry, privacy, key),
+    ]);
+    return Object.fromEntries(entries);
+}
+export function isExcludedTool(toolName, privacy) {
+    return privacy.excludeToolPrefixes.some((prefix) => toolName.startsWith(prefix));
+}
+export function matchesExcludedPath(candidates, privacy) {
+    return candidates.some((candidate) => typeof candidate === 'string' &&
+        candidate.length > 0 &&
+        privacy.excludePathPatterns.some((pattern) => matchesPattern(candidate, pattern)));
+}

package/dist/search-ranking.d.ts

@@ -0,0 +1,12 @@
+import type { SearchResult } from './types.js';
+export type SearchCandidate = {
+    id: string;
+    type: string;
+    sessionID?: string;
+    timestamp: number;
+    snippet: string;
+    content: string;
+    sourceKind: 'message' | 'summary' | 'artifact';
+    sourceOrder: number;
+};
+export declare function rankSearchCandidates(candidates: SearchCandidate[], query: string, limit: number): SearchResult[];

package/dist/search-ranking.js

@@ -0,0 +1,98 @@
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function tokenizeQuery(query) {
+    return [...new Set(query.toLowerCase().match(/[a-z0-9_]+/g) ?? [])];
+}
+function buildRecencyRange(candidates) {
+    let oldest = Number.POSITIVE_INFINITY;
+    let newest = Number.NEGATIVE_INFINITY;
+    for (const candidate of candidates) {
+        oldest = Math.min(oldest, candidate.timestamp);
+        newest = Math.max(newest, candidate.timestamp);
+    }
+    if (!Number.isFinite(oldest) || !Number.isFinite(newest)) {
+        return { oldest: 0, newest: 0 };
+    }
+    return { oldest, newest };
+}
+const MESSAGE_BASE_SCORE = 135;
+const ARTIFACT_BASE_SCORE = 96;
+const SUMMARY_BASE_SCORE = 78;
+const USER_ROLE_BONUS = 22;
+const ASSISTANT_ROLE_BONUS = 12;
+const EXACT_PHRASE_BONUS = 90;
+const COVERAGE_MULTIPLIER = 70;
+const TOKEN_MATCH_MULTIPLIER = 12;
+const TOTAL_HIT_MULTIPLIER = 2;
+const BOUNDARY_HIT_MULTIPLIER = 4;
+const SNIPPET_EXACT_BONUS = 24;
+const SOURCE_ORDER_DECAY_BASE = 18;
+const RECENCY_MULTIPLIER = 28;
+function scoreSearchCandidate(candidate, query, tokens, recencyRange) {
+    const content = candidate.content.toLowerCase();
+    const snippet = candidate.snippet.toLowerCase();
+    const exactPhrase = content.includes(query);
+    const base = candidate.sourceKind === 'message'
+        ? MESSAGE_BASE_SCORE
+        : candidate.sourceKind === 'artifact'
+            ? ARTIFACT_BASE_SCORE
+            : SUMMARY_BASE_SCORE;
+    let matchedTokens = 0;
+    let totalHits = 0;
+    let boundaryHits = 0;
+    for (const token of tokens) {
+        const hasToken = content.includes(token);
+        if (hasToken)
+            matchedTokens += 1;
+        const boundaryPattern = new RegExp(`\\b${escapeRegExp(token)}\\b`, 'g');
+        const matches = content.match(boundaryPattern)?.length ?? 0;
+        boundaryHits += matches;
+        totalHits += matches > 0 ? matches : hasToken ? 1 : 0;
+    }
+    const coverage = tokens.length > 0 ? matchedTokens / tokens.length : 0;
+    let score = base;
+    if (candidate.sourceKind === 'message') {
+        score +=
+            candidate.type === 'user'
+                ? USER_ROLE_BONUS
+                : candidate.type === 'assistant'
+                    ? ASSISTANT_ROLE_BONUS
+                    : 0;
+    }
+    score += exactPhrase ? EXACT_PHRASE_BONUS : 0;
+    score += coverage * COVERAGE_MULTIPLIER;
+    score += matchedTokens * TOKEN_MATCH_MULTIPLIER;
+    score += Math.min(totalHits, matchedTokens + 2) * TOTAL_HIT_MULTIPLIER;
+    score += Math.min(boundaryHits, matchedTokens) * BOUNDARY_HIT_MULTIPLIER;
+    score += snippet.includes(query) ? SNIPPET_EXACT_BONUS : 0;
+    score += Math.max(0, SOURCE_ORDER_DECAY_BASE - candidate.sourceOrder);
+    if (recencyRange.newest > recencyRange.oldest) {
+        const recencyRatio = (candidate.timestamp - recencyRange.oldest) / (recencyRange.newest - recencyRange.oldest);
+        score += recencyRatio * RECENCY_MULTIPLIER;
+    }
+    return score;
+}
+export function rankSearchCandidates(candidates, query, limit) {
+    const exactQuery = query.toLowerCase();
+    const tokens = tokenizeQuery(query);
+    const deduped = new Map();
+    const recencyRange = buildRecencyRange(candidates);
+    for (const candidate of candidates) {
+        const score = scoreSearchCandidate(candidate, exactQuery, tokens, recencyRange);
+        const key = `${candidate.type}:${candidate.id}`;
+        const existing = deduped.get(key);
+        if (!existing ||
+            score > existing.score ||
+            (score === existing.score && candidate.timestamp > existing.timestamp)) {
+            deduped.set(key, {
+                ...candidate,
+                score,
+            });
+        }
+    }
+    return [...deduped.values()]
+        .sort((a, b) => b.score - a.score || b.timestamp - a.timestamp)
+        .slice(0, limit)
+        .map(({ content: _content, sourceKind: _sourceKind, sourceOrder: _sourceOrder, score: _score, ...result }) => result);
+}

package/dist/sql-utils.d.ts

@@ -0,0 +1,31 @@
+import type { SqlDatabaseLike, SqlStatementLike } from './store-types.js';
+/**
+ * Validates that a SQL statement result contains the expected number of rows.
+ * Throws a descriptive error if the constraint is violated.
+ */
+export declare function assertSingleRow(result: unknown, operation: string): asserts result is Record<string, unknown>;
+/**
+ * Validates that a SQL statement affected at least one row.
+ * Useful for UPDATE/DELETE operations where zero rows may indicate a bug.
+ */
+export declare function assertAffectedRows(statement: SqlStatementLike, args: unknown[], operation: string, minRows?: number): void;
+/**
+ * Safely executes a SQL statement and returns typed results.
+ * Wraps the raw SQLite call with validation to catch schema mismatches early.
+ */
+export declare function safeQuery<T extends Record<string, unknown>>(statement: SqlStatementLike, args: unknown[], operation: string): T[];
+/**
+ * Safely executes a SQL statement that should return exactly one row.
+ */
+export declare function safeQueryOne<T extends Record<string, unknown>>(statement: SqlStatementLike, args: unknown[], operation: string): T | undefined;
+/**
+ * Wraps database operations in a transaction with proper error handling.
+ * Automatically rolls back on failure.
+ */
+export declare function withTransaction(db: SqlDatabaseLike, operation: string, fn: () => void): void;
+/**
+ * Lightweight runtime validator for SQL row results.
+ * Checks that required keys exist and have the expected types.
+ * Returns the row as-is if valid, throws if not.
+ */
+export declare function validateRow<T extends Record<string, unknown>>(row: unknown, schema: Record<keyof T, 'string' | 'number' | 'boolean' | 'object' | 'nullable'>, operation: string): T;

package/dist/sql-utils.js

@@ -0,0 +1,80 @@
+/**
+ * Validates that a SQL statement result contains the expected number of rows.
+ * Throws a descriptive error if the constraint is violated.
+ */
+export function assertSingleRow(result, operation) {
+    if (!result || typeof result !== 'object') {
+        throw new Error(`${operation}: expected a single row, got ${typeof result}`);
+    }
+}
+/**
+ * Validates that a SQL statement affected at least one row.
+ * Useful for UPDATE/DELETE operations where zero rows may indicate a bug.
+ */
+export function assertAffectedRows(statement, args, operation, minRows = 1) {
+    const result = statement.run(...args);
+    const changes = result?.changes ?? 0;
+    if (changes < minRows) {
+        throw new Error(`${operation}: expected at least ${minRows} affected rows, got ${changes}`);
+    }
+}
+/**
+ * Safely executes a SQL statement and returns typed results.
+ * Wraps the raw SQLite call with validation to catch schema mismatches early.
+ */
+export function safeQuery(statement, args, operation) {
+    const result = statement.all(...args);
+    if (!Array.isArray(result)) {
+        throw new Error(`${operation}: expected array result, got ${typeof result}`);
+    }
+    return result;
+}
+/**
+ * Safely executes a SQL statement that should return exactly one row.
+ */
+export function safeQueryOne(statement, args, operation) {
+    const result = statement.get(...args);
+    if (result && typeof result !== 'object') {
+        throw new Error(`${operation}: expected object or undefined, got ${typeof result}`);
+    }
+    return result;
+}
+/**
+ * Wraps database operations in a transaction with proper error handling.
+ * Automatically rolls back on failure.
+ */
+export function withTransaction(db, operation, fn) {
+    db.exec('BEGIN');
+    try {
+        fn();
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${operation} transaction failed: ${message}`);
+    }
+}
+/**
+ * Lightweight runtime validator for SQL row results.
+ * Checks that required keys exist and have the expected types.
+ * Returns the row as-is if valid, throws if not.
+ */
+export function validateRow(row, schema, operation) {
+    if (!row || typeof row !== 'object' || Array.isArray(row)) {
+        throw new Error(`${operation}: expected an object row, got ${typeof row}`);
+    }
+    const record = row;
+    for (const [key, expectedType] of Object.entries(schema)) {
+        const value = record[key];
+        if (expectedType === 'nullable')
+            continue;
+        if (value === null || value === undefined) {
+            throw new Error(`${operation}: missing required column "${key}"`);
+        }
+        if (typeof value !== expectedType) {
+            throw new Error(`${operation}: column "${key}" expected ${expectedType}, got ${typeof value}`);
+        }
+    }
+    return record;
+}

package/dist/store-artifacts.d.ts

@@ -0,0 +1,50 @@
+import { type CompiledPrivacyOptions } from './privacy.js';
+import type { ArtifactBlobRow, ArtifactRow } from './store-snapshot.js';
+import type { SqlDatabaseLike } from './store-types.js';
+import type { ConversationMessage, NormalizedSession } from './types.js';
+export type ArtifactData = {
+    artifactID: string;
+    sessionID: string;
+    messageID: string;
+    partID: string;
+    artifactKind: string;
+    fieldName: string;
+    previewText: string;
+    contentText: string;
+    contentHash: string;
+    charCount: number;
+    createdAt: number;
+    metadata: Record<string, unknown>;
+};
+export type ExternalizedMessage = {
+    storedMessage: ConversationMessage;
+    artifacts: ArtifactData[];
+};
+export type ExternalizedSession = {
+    storedSession: NormalizedSession;
+    artifacts: ArtifactData[];
+};
+export type StoreArtifactBindings = {
+    workspaceDirectory: string;
+    options: {
+        artifactPreviewChars: number;
+        binaryPreviewProviders: string[];
+        largeContentThreshold: number;
+        previewBytePeek: number;
+        privacy: CompiledPrivacyOptions;
+    };
+    getDb(): SqlDatabaseLike;
+    readArtifactBlobSync(contentHash?: string | null): ArtifactBlobRow | undefined;
+    upsertSessionRowSync(session: NormalizedSession): void;
+    upsertMessageInfoSync(sessionID: string, message: ConversationMessage): void;
+    deleteMessageSync(sessionID: string, messageID: string): void;
+    replaceMessageSearchRowSync(sessionID: string, message: ConversationMessage): void;
+    replaceMessageSearchRowsSync(session: NormalizedSession): void;
+};
+export declare function formatArtifactMetadataLines(metadata: Record<string, unknown>): string[];
+export declare function buildArtifactSearchContent(artifact: ArtifactData): string;
+export declare function externalizeMessage(bindings: StoreArtifactBindings, message: ConversationMessage): Promise<ExternalizedMessage>;
+export declare function externalizeSession(bindings: StoreArtifactBindings, session: NormalizedSession): Promise<ExternalizedSession>;
+export declare function persistStoredSessionSync(bindings: StoreArtifactBindings, storedSession: NormalizedSession, artifacts: ArtifactData[]): void;
+export declare function replaceStoredMessageSync(bindings: StoreArtifactBindings, sessionID: string, storedMessage: ConversationMessage, artifacts: ArtifactData[]): void;
+export declare function materializeArtifactRow(bindings: StoreArtifactBindings, row: ArtifactRow): ArtifactData;