opencode-gateway 0.2.3 → 0.2.5

package/dist/store/sqlite.js

@@ -1,777 +0,0 @@
-import { Database } from "bun:sqlite";
-import { mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
-import { migrateGatewayDatabase } from "./migrations";
-export class SqliteStore {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    getSessionBinding(conversationKey) {
-        const row = this.db
-            .query("SELECT session_id FROM session_bindings WHERE conversation_key = ?1;")
-            .get(conversationKey);
-        return row?.session_id ?? null;
-    }
-    putSessionBinding(conversationKey, sessionId, recordedAtMs) {
-        this.db
-            .query(`
-                    INSERT INTO session_bindings (conversation_key, session_id, updated_at_ms)
-                    VALUES (?1, ?2, ?3)
-                    ON CONFLICT(conversation_key) DO UPDATE SET
-                        session_id = excluded.session_id,
-                        updated_at_ms = excluded.updated_at_ms;
-                `)
-            .run(conversationKey, sessionId, recordedAtMs);
-    }
-    putSessionBindingIfUnchanged(conversationKey, expectedSessionId, nextSessionId, recordedAtMs) {
-        const result = expectedSessionId === null
-            ? this.db
-                .query(`
-                              INSERT INTO session_bindings (conversation_key, session_id, updated_at_ms)
-                              VALUES (?1, ?2, ?3)
-                              ON CONFLICT(conversation_key) DO NOTHING;
-                          `)
-                .run(conversationKey, nextSessionId, recordedAtMs)
-            : this.db
-                .query(`
-                              UPDATE session_bindings
-                              SET session_id = ?2,
-                                  updated_at_ms = ?3
-                              WHERE conversation_key = ?1
-                                AND session_id = ?4;
-                          `)
-                .run(conversationKey, nextSessionId, recordedAtMs, expectedSessionId);
-        return result.changes > 0;
-    }
-    deleteSessionBinding(conversationKey) {
-        this.db.query("DELETE FROM session_bindings WHERE conversation_key = ?1;").run(conversationKey);
-    }
-    clearSessionReplyTargets(sessionId) {
-        this.db.query("DELETE FROM session_reply_targets WHERE session_id = ?1;").run(sessionId);
-    }
-    replaceSessionReplyTargets(input) {
-        assertSafeInteger(input.recordedAtMs, "session reply-target recordedAtMs");
-        const deleteTargets = this.db.query("DELETE FROM session_reply_targets WHERE session_id = ?1;");
-        const insertTarget = this.db.query(`
-                INSERT INTO session_reply_targets (
-                    session_id,
-                    ordinal,
-                    conversation_key,
-                    delivery_channel,
-                    delivery_target,
-                    delivery_topic,
-                    updated_at_ms
-                )
-                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7);
-            `);
-        this.db.transaction((payload) => {
-            deleteTargets.run(payload.sessionId);
-            for (const [ordinal, target] of payload.targets.entries()) {
-                insertTarget.run(payload.sessionId, ordinal, payload.conversationKey, target.channel, target.target, normalizeKeyField(target.topic), payload.recordedAtMs);
-            }
-        })(input);
-    }
-    listSessionReplyTargets(sessionId) {
-        const rows = this.db
-            .query(`
-                    SELECT
-                        session_id,
-                        ordinal,
-                        conversation_key,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        updated_at_ms
-                    FROM session_reply_targets
-                    WHERE session_id = ?1
-                    ORDER BY ordinal ASC;
-                `)
-            .all(sessionId);
-        return rows.map(mapSessionReplyTargetRow);
-    }
-    getDefaultSessionReplyTarget(sessionId) {
-        const row = this.db
-            .query(`
-                    SELECT
-                        session_id,
-                        ordinal,
-                        conversation_key,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        updated_at_ms
-                    FROM session_reply_targets
-                    WHERE session_id = ?1
-                    ORDER BY ordinal ASC
-                    LIMIT 1;
-                `)
-            .get(sessionId);
-        return row ? mapSessionReplyTargetRow(row) : null;
-    }
-    hasGatewaySession(sessionId) {
-        const binding = this.db
-            .query(`
-                    SELECT 1 AS present
-                    FROM session_bindings
-                    WHERE session_id = ?1
-                    LIMIT 1;
-                `)
-            .get(sessionId);
-        if (binding?.present === 1) {
-            return true;
-        }
-        const replyTarget = this.db
-            .query(`
-                    SELECT 1 AS present
-                    FROM session_reply_targets
-                    WHERE session_id = ?1
-                    LIMIT 1;
-                `)
-            .get(sessionId);
-        return replyTarget?.present === 1;
-    }
-    appendJournal(entry) {
-        this.db
-            .query(`
-                    INSERT INTO runtime_journal (kind, recorded_at_ms, conversation_key, payload_json)
-                    VALUES (?1, ?2, ?3, ?4);
-                `)
-            .run(entry.kind, entry.recordedAtMs, entry.conversationKey, JSON.stringify(entry.payload));
-    }
-    replacePendingQuestion(input) {
-        assertSafeInteger(input.recordedAtMs, "pending question recordedAtMs");
-        const deleteQuestion = this.db.query("DELETE FROM pending_questions WHERE request_id = ?1;");
-        const insertQuestion = this.db.query(`
-                INSERT INTO pending_questions (
-                    request_id,
-                    session_id,
-                    delivery_channel,
-                    delivery_target,
-                    delivery_topic,
-                    question_json,
-                    telegram_message_id,
-                    created_at_ms
-                )
-                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8);
-            `);
-        this.db.transaction((payload) => {
-            deleteQuestion.run(payload.requestId);
-            for (const target of payload.targets) {
-                insertQuestion.run(payload.requestId, payload.sessionId, target.deliveryTarget.channel, target.deliveryTarget.target, normalizeKeyField(target.deliveryTarget.topic), JSON.stringify(payload.questions), target.telegramMessageId, payload.recordedAtMs);
-            }
-        })(input);
-    }
-    deletePendingQuestion(requestId) {
-        this.db.query("DELETE FROM pending_questions WHERE request_id = ?1;").run(requestId);
-    }
-    deletePendingQuestionsForSession(sessionId) {
-        this.db.query("DELETE FROM pending_questions WHERE session_id = ?1;").run(sessionId);
-    }
-    getPendingQuestionForTarget(target) {
-        const row = this.db
-            .query(`
-                    SELECT
-                        id,
-                        request_id,
-                        session_id,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        question_json,
-                        telegram_message_id,
-                        created_at_ms
-                    FROM pending_questions
-                    WHERE delivery_channel = ?1
-                      AND delivery_target = ?2
-                      AND delivery_topic = ?3
-                    ORDER BY created_at_ms ASC, id ASC
-                    LIMIT 1;
-                `)
-            .get(target.channel, target.target, normalizeKeyField(target.topic));
-        return row ? mapPendingQuestionRow(row) : null;
-    }
-    getPendingQuestionForTelegramMessage(target, telegramMessageId) {
-        assertSafeInteger(telegramMessageId, "pending question telegramMessageId");
-        const row = this.db
-            .query(`
-                    SELECT
-                        id,
-                        request_id,
-                        session_id,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        question_json,
-                        telegram_message_id,
-                        created_at_ms
-                    FROM pending_questions
-                    WHERE delivery_channel = ?1
-                      AND delivery_target = ?2
-                      AND delivery_topic = ?3
-                      AND telegram_message_id = ?4
-                    ORDER BY created_at_ms ASC, id ASC
-                    LIMIT 1;
-                `)
-            .get(target.channel, target.target, normalizeKeyField(target.topic), telegramMessageId);
-        return row ? mapPendingQuestionRow(row) : null;
-    }
-    hasMailboxEntry(sourceKind, externalId) {
-        const row = this.db
-            .query(`
-                    SELECT 1 AS present
-                    FROM mailbox_entries
-                    WHERE source_kind = ?1 AND external_id = ?2
-                    LIMIT 1;
-                `)
-            .get(sourceKind, externalId);
-        return row?.present === 1;
-    }
-    enqueueMailboxEntry(input) {
-        assertSafeInteger(input.recordedAtMs, "mailbox recordedAtMs");
-        const insertEntry = this.db.query(`
-                INSERT INTO mailbox_entries (
-                    mailbox_key,
-                    source_kind,
-                    external_id,
-                    sender,
-                    body,
-                    reply_channel,
-                    reply_target,
-                    reply_topic,
-                    created_at_ms
-                )
-                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
-                ON CONFLICT(source_kind, external_id) DO NOTHING;
-            `);
-        const insertAttachment = this.db.query(`
-                INSERT INTO mailbox_entry_attachments (
-                    mailbox_entry_id,
-                    ordinal,
-                    kind,
-                    mime_type,
-                    file_name,
-                    local_path
-                )
-                VALUES (?1, ?2, ?3, ?4, ?5, ?6);
-            `);
-        this.db.transaction((payload) => {
-            const result = insertEntry.run(payload.mailboxKey, payload.sourceKind, payload.externalId, payload.sender, payload.text ?? "", payload.replyChannel, payload.replyTarget, payload.replyTopic, payload.recordedAtMs);
-            if (result.changes === 0) {
-                return;
-            }
-            const entryId = Number(result.lastInsertRowid);
-            for (const [index, attachment] of payload.attachments.entries()) {
-                insertAttachment.run(entryId, index, attachment.kind, attachment.mimeType, attachment.fileName, attachment.localPath);
-            }
-        })(input);
-    }
-    listPendingMailboxKeys() {
-        const rows = this.db
-            .query(`
-                    SELECT DISTINCT mailbox_key
-                    FROM mailbox_entries
-                    ORDER BY mailbox_key ASC;
-                `)
-            .all();
-        return rows.map((row) => row.mailbox_key);
-    }
-    listMailboxEntries(mailboxKey) {
-        const rows = this.db
-            .query(`
-                    SELECT
-                        id,
-                        mailbox_key,
-                        source_kind,
-                        external_id,
-                        sender,
-                        body,
-                        reply_channel,
-                        reply_target,
-                        reply_topic,
-                        created_at_ms
-                    FROM mailbox_entries
-                    WHERE mailbox_key = ?1
-                    ORDER BY id ASC;
-                `)
-            .all(mailboxKey);
-        const attachments = listMailboxAttachments(this.db, rows.map((row) => row.id));
-        return rows.map((row) => mapMailboxEntryRow(row, attachments.get(row.id) ?? []));
-    }
-    deleteMailboxEntries(ids) {
-        if (ids.length === 0) {
-            return;
-        }
-        for (const id of ids) {
-            assertSafeInteger(id, "mailbox entry id");
-        }
-        const placeholders = ids.map((_, index) => `?${index + 1}`).join(", ");
-        this.db.query(`DELETE FROM mailbox_entries WHERE id IN (${placeholders});`).run(...ids);
-    }
-    getTelegramUpdateOffset() {
-        const value = this.getStateValue("telegram.update_offset");
-        if (value === null) {
-            return null;
-        }
-        return parseStoredInteger(value, "stored telegram.update_offset");
-    }
-    putTelegramUpdateOffset(offset, recordedAtMs) {
-        assertSafeInteger(offset, "telegram update offset");
-        this.putStateValue("telegram.update_offset", String(offset), recordedAtMs);
-    }
-    getStateValue(key) {
-        const row = this.db.query("SELECT value FROM kv_state WHERE key = ?1;").get(key);
-        return row?.value ?? null;
-    }
-    putStateValue(key, value, recordedAtMs) {
-        this.db
-            .query(`
-                    INSERT INTO kv_state (key, value, updated_at_ms)
-                    VALUES (?1, ?2, ?3)
-                    ON CONFLICT(key) DO UPDATE SET
-                        value = excluded.value,
-                        updated_at_ms = excluded.updated_at_ms;
-                `)
-            .run(key, value, recordedAtMs);
-    }
-    upsertCronJob(input) {
-        assertSafeInteger(input.nextRunAtMs, "cron next_run_at_ms");
-        assertSafeInteger(input.recordedAtMs, "cron recordedAtMs");
-        if (input.runAtMs !== null) {
-            assertSafeInteger(input.runAtMs, "cron run_at_ms");
-        }
-        this.db
-            .query(`
-                    INSERT INTO cron_jobs (
-                        id,
-                        kind,
-                        schedule,
-                        run_at_ms,
-                        prompt,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        enabled,
-                        next_run_at_ms,
-                        created_at_ms,
-                        updated_at_ms
-                    )
-                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?11)
-                    ON CONFLICT(id) DO UPDATE SET
-                        kind = excluded.kind,
-                        schedule = excluded.schedule,
-                        run_at_ms = excluded.run_at_ms,
-                        prompt = excluded.prompt,
-                        delivery_channel = excluded.delivery_channel,
-                        delivery_target = excluded.delivery_target,
-                        delivery_topic = excluded.delivery_topic,
-                        enabled = excluded.enabled,
-                        next_run_at_ms = excluded.next_run_at_ms,
-                        updated_at_ms = excluded.updated_at_ms;
-                `)
-            .run(input.id, input.kind, encodeStoredSchedule(input.kind, input.schedule), input.runAtMs, input.prompt, input.deliveryChannel, input.deliveryTarget, input.deliveryTopic, input.enabled ? 1 : 0, input.nextRunAtMs, input.recordedAtMs);
-    }
-    getCronJob(id) {
-        const row = this.db
-            .query(`
-                    SELECT
-                        id,
-                        kind,
-                        schedule,
-                        run_at_ms,
-                        prompt,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        enabled,
-                        next_run_at_ms,
-                        created_at_ms,
-                        updated_at_ms
-                    FROM cron_jobs
-                    WHERE id = ?1;
-                `)
-            .get(id);
-        return row ? mapCronJobRow(row) : null;
-    }
-    listCronJobs() {
-        const rows = this.db
-            .query(`
-                    SELECT
-                        id,
-                        kind,
-                        schedule,
-                        run_at_ms,
-                        prompt,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        enabled,
-                        next_run_at_ms,
-                        created_at_ms,
-                        updated_at_ms
-                    FROM cron_jobs
-                    ORDER BY id ASC;
-                `)
-            .all();
-        return rows.map(mapCronJobRow);
-    }
-    listOverdueCronJobs(nowMs) {
-        assertSafeInteger(nowMs, "cron nowMs");
-        const rows = this.db
-            .query(`
-                    SELECT
-                        id,
-                        kind,
-                        schedule,
-                        run_at_ms,
-                        prompt,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        enabled,
-                        next_run_at_ms,
-                        created_at_ms,
-                        updated_at_ms
-                    FROM cron_jobs
-                    WHERE kind = 'cron' AND enabled = 1 AND next_run_at_ms <= ?1
-                    ORDER BY next_run_at_ms ASC, id ASC;
-                `)
-            .all(nowMs);
-        return rows.map(mapCronJobRow);
-    }
-    listDueCronJobs(nowMs, limit) {
-        assertSafeInteger(nowMs, "cron nowMs");
-        assertSafeInteger(limit, "cron due-job limit");
-        const rows = this.db
-            .query(`
-                    SELECT
-                        id,
-                        kind,
-                        schedule,
-                        run_at_ms,
-                        prompt,
-                        delivery_channel,
-                        delivery_target,
-                        delivery_topic,
-                        enabled,
-                        next_run_at_ms,
-                        created_at_ms,
-                        updated_at_ms
-                    FROM cron_jobs
-                    WHERE enabled = 1 AND next_run_at_ms <= ?1
-                    ORDER BY next_run_at_ms ASC, id ASC
-                    LIMIT ?2;
-                `)
-            .all(nowMs, limit);
-        return rows.map(mapCronJobRow);
-    }
-    removeCronJob(id) {
-        const result = this.db.query("DELETE FROM cron_jobs WHERE id = ?1;").run(id);
-        return result.changes > 0;
-    }
-    updateCronJobNextRun(id, nextRunAtMs, recordedAtMs) {
-        assertSafeInteger(nextRunAtMs, "cron next_run_at_ms");
-        assertSafeInteger(recordedAtMs, "cron recordedAtMs");
-        this.db
-            .query(`
-                    UPDATE cron_jobs
-                    SET next_run_at_ms = ?2, updated_at_ms = ?3
-                    WHERE id = ?1;
-                `)
-            .run(id, nextRunAtMs, recordedAtMs);
-    }
-    setCronJobEnabled(id, enabled, recordedAtMs) {
-        assertSafeInteger(recordedAtMs, "cron recordedAtMs");
-        this.db
-            .query(`
-                    UPDATE cron_jobs
-                    SET enabled = ?2,
-                        updated_at_ms = ?3
-                    WHERE id = ?1;
-                `)
-            .run(id, enabled ? 1 : 0, recordedAtMs);
-    }
-    listCronRuns(jobId, limit) {
-        assertSafeInteger(limit, "cron run limit");
-        const rows = this.db
-            .query(`
-                    SELECT
-                        id,
-                        job_id,
-                        scheduled_for_ms,
-                        started_at_ms,
-                        finished_at_ms,
-                        status,
-                        response_text,
-                        error_message
-                    FROM cron_runs
-                    WHERE job_id = ?1
-                    ORDER BY started_at_ms DESC, id DESC
-                    LIMIT ?2;
-                `)
-            .all(jobId, limit);
-        return rows.map((row) => ({
-            id: row.id,
-            jobId: row.job_id,
-            scheduledForMs: row.scheduled_for_ms,
-            startedAtMs: row.started_at_ms,
-            finishedAtMs: row.finished_at_ms,
-            status: row.status,
-            responseText: row.response_text,
-            errorMessage: row.error_message,
-        }));
-    }
-    insertCronRun(jobId, scheduledForMs, startedAtMs) {
-        assertSafeInteger(scheduledForMs, "cron scheduled_for_ms");
-        assertSafeInteger(startedAtMs, "cron started_at_ms");
-        const result = this.db
-            .query(`
-                    INSERT INTO cron_runs (
-                        job_id,
-                        scheduled_for_ms,
-                        started_at_ms,
-                        finished_at_ms,
-                        status,
-                        response_text,
-                        error_message
-                    )
-                    VALUES (?1, ?2, ?3, NULL, 'running', NULL, NULL);
-                `)
-            .run(jobId, scheduledForMs, startedAtMs);
-        return Number(result.lastInsertRowid);
-    }
-    finishCronRun(runId, status, finishedAtMs, responseText, errorMessage) {
-        assertSafeInteger(runId, "cron run id");
-        assertSafeInteger(finishedAtMs, "cron finished_at_ms");
-        this.db
-            .query(`
-                    UPDATE cron_runs
-                    SET
-                        finished_at_ms = ?2,
-                        status = ?3,
-                        response_text = ?4,
-                        error_message = ?5
-                    WHERE id = ?1;
-                `)
-            .run(runId, finishedAtMs, status, responseText, errorMessage);
-    }
-    abandonRunningCronRuns(finishedAtMs) {
-        assertSafeInteger(finishedAtMs, "cron abandoned finished_at_ms");
-        const result = this.db
-            .query(`
-                    UPDATE cron_runs
-                    SET
-                        finished_at_ms = ?1,
-                        status = 'abandoned',
-                        error_message = 'gateway process stopped before this run completed'
-                    WHERE status = 'running';
-                `)
-            .run(finishedAtMs);
-        return result.changes;
-    }
-    close() {
-        this.db.close();
-    }
-}
-function mapCronJobRow(row) {
-    const kind = parseScheduleJobKind(row.kind);
-    return {
-        id: row.id,
-        kind,
-        schedule: kind === "cron" ? row.schedule : null,
-        runAtMs: row.run_at_ms,
-        prompt: row.prompt,
-        deliveryChannel: row.delivery_channel,
-        deliveryTarget: row.delivery_target,
-        deliveryTopic: row.delivery_topic,
-        enabled: row.enabled === 1,
-        nextRunAtMs: row.next_run_at_ms,
-        createdAtMs: row.created_at_ms,
-        updatedAtMs: row.updated_at_ms,
-    };
-}
-function parseScheduleJobKind(value) {
-    switch (value) {
-        case "cron":
-        case "once":
-            return value;
-        default:
-            throw new Error(`stored schedule job kind is invalid: ${value}`);
-    }
-}
-function encodeStoredSchedule(kind, schedule) {
-    if (kind === "once") {
-        return "@once";
-    }
-    if (schedule === null) {
-        throw new Error("cron schedule must not be null");
-    }
-    return schedule;
-}
-function mapMailboxEntryRow(row, attachments) {
-    return {
-        id: row.id,
-        mailboxKey: row.mailbox_key,
-        sourceKind: row.source_kind,
-        externalId: row.external_id,
-        sender: row.sender,
-        text: normalizeStoredMailboxText(row.body),
-        attachments,
-        replyChannel: row.reply_channel,
-        replyTarget: row.reply_target,
-        replyTopic: row.reply_topic,
-        createdAtMs: row.created_at_ms,
-    };
-}
-function listMailboxAttachments(db, entryIds) {
-    if (entryIds.length === 0) {
-        return new Map();
-    }
-    for (const entryId of entryIds) {
-        assertSafeInteger(entryId, "mailbox entry id");
-    }
-    const placeholders = entryIds.map((_, index) => `?${index + 1}`).join(", ");
-    const rows = db
-        .query(`
-                SELECT
-                    mailbox_entry_id,
-                    ordinal,
-                    kind,
-                    mime_type,
-                    file_name,
-                    local_path
-                FROM mailbox_entry_attachments
-                WHERE mailbox_entry_id IN (${placeholders})
-                ORDER BY mailbox_entry_id ASC, ordinal ASC;
-            `)
-        .all(...entryIds);
-    const attachments = new Map();
-    for (const row of rows) {
-        const records = attachments.get(row.mailbox_entry_id) ?? [];
-        records.push(mapMailboxEntryAttachmentRow(row));
-        attachments.set(row.mailbox_entry_id, records);
-    }
-    return attachments;
-}
-function mapMailboxEntryAttachmentRow(row) {
-    switch (row.kind) {
-        case "image":
-            return {
-                kind: "image",
-                ordinal: row.ordinal,
-                mimeType: row.mime_type,
-                fileName: row.file_name,
-                localPath: row.local_path,
-            };
-        default:
-            throw new Error(`unsupported mailbox attachment kind: ${row.kind}`);
-    }
-}
-function mapSessionReplyTargetRow(row) {
-    return {
-        channel: row.delivery_channel,
-        target: row.delivery_target,
-        topic: normalizeStoredKeyField(row.delivery_topic),
-    };
-}
-function mapPendingQuestionRow(row) {
-    return {
-        requestId: row.request_id,
-        sessionId: row.session_id,
-        questions: parsePendingQuestions(row.question_json),
-        deliveryTarget: {
-            channel: row.delivery_channel,
-            target: row.delivery_target,
-            topic: normalizeStoredKeyField(row.delivery_topic),
-        },
-        telegramMessageId: row.telegram_message_id,
-        createdAtMs: row.created_at_ms,
-    };
-}
-function parsePendingQuestions(value) {
-    const parsed = JSON.parse(value);
-    if (!Array.isArray(parsed)) {
-        throw new Error("stored pending question payload is invalid");
-    }
-    return parsed.map((question, index) => {
-        if (typeof question !== "object" || question === null) {
-            throw new Error(`stored pending question ${index} is invalid`);
-        }
-        const header = readRequiredStringField(question, "header");
-        const prompt = readRequiredStringField(question, "question");
-        const rawOptions = readArrayField(question, "options");
-        const options = rawOptions.map((option, optionIndex) => {
-            if (typeof option !== "object" || option === null) {
-                throw new Error(`stored pending question option ${index}:${optionIndex} is invalid`);
-            }
-            return {
-                label: readRequiredStringField(option, "label"),
-                description: readRequiredStringField(option, "description"),
-            };
-        });
-        return {
-            header,
-            question: prompt,
-            options,
-            multiple: readBooleanField(question, "multiple", false),
-            custom: readBooleanField(question, "custom", true),
-        };
-    });
-}
-function assertSafeInteger(value, field) {
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new Error(`${field} is out of range: ${value}`);
-    }
-}
-function parseStoredInteger(value, field) {
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isSafeInteger(parsed) || parsed < 0) {
-        throw new Error(`${field} is invalid: ${value}`);
-    }
-    return parsed;
-}
-function normalizeStoredMailboxText(value) {
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? null : trimmed;
-}
-function normalizeKeyField(value) {
-    if (value === null) {
-        return "";
-    }
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? "" : trimmed;
-}
-function normalizeStoredKeyField(value) {
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? null : trimmed;
-}
-function readRequiredStringField(value, field) {
-    const raw = value[field];
-    if (typeof raw !== "string" || raw.trim().length === 0) {
-        throw new Error(`stored field ${field} is invalid`);
-    }
-    return raw;
-}
-function readArrayField(value, field) {
-    const raw = value[field];
-    if (!Array.isArray(raw)) {
-        throw new Error(`stored field ${field} is invalid`);
-    }
-    return raw;
-}
-function readBooleanField(value, field, fallback) {
-    const raw = value[field];
-    if (raw === undefined) {
-        return fallback;
-    }
-    if (typeof raw !== "boolean") {
-        throw new Error(`stored field ${field} is invalid`);
-    }
-    return raw;
-}
-export async function openSqliteStore(path) {
-    await mkdir(dirname(path), { recursive: true });
-    const db = new Database(path);
-    migrateGatewayDatabase(db);
-    return new SqliteStore(db);
-}