@askdkc/kiokuko 0.1.0

package/dist/context/delivery.js

@@ -0,0 +1,758 @@
+import { withImmediateTransaction } from '../db/transaction.js';
+import { KiokukoError } from '../errors.js';
+import { CONTEXT_RANKING_COMPONENTS, CONTEXT_SELECTION_REASON_ORDER } from './ranking.js';
+import { sanitizeJson } from '../security/sanitize.js';
+import { canonicalJson } from '../serialization/validate.js';
+const MAX_IDENTIFIER_BYTES = 256;
+const MAX_ITEMS = 100;
+const MAX_SCORE_COMPONENT = 1_000_000;
+const MAX_CHAR_BUDGET = 100_000;
+const MAX_EXTERNAL_SUMMARY_BYTES = 16 * 1024;
+const MAX_EXTERNAL_ERROR_BYTES = 1024;
+const MAX_SOURCES = 16;
+const MAX_LIMIT = 100;
+const DEFAULT_LIMIT = 100;
+const DELIVERY_CURSOR_VERSION = 1;
+const VALIDATION_MESSAGE = 'Context delivery input is invalid';
+const NOT_FOUND_MESSAGE = 'Context delivery target was not found';
+const CONFLICT_MESSAGE = 'Context delivery conflicts with existing record';
+const DATABASE_MESSAGE = 'Context delivery database operation failed';
+const INTEGRITY_MESSAGE = 'Stored context delivery is invalid';
+function fail(code, message) {
+    throw new KiokukoError(code, message);
+}
+function validation() {
+    return fail('VALIDATION_ERROR', VALIDATION_MESSAGE);
+}
+function notFound() {
+    return fail('NOT_FOUND', NOT_FOUND_MESSAGE);
+}
+function conflict() {
+    return fail('CONFLICT', CONFLICT_MESSAGE);
+}
+function databaseFailure() {
+    return fail('DATABASE_ERROR', DATABASE_MESSAGE);
+}
+function integrity() {
+    return fail('INTEGRITY_ERROR', INTEGRITY_MESSAGE);
+}
+function isKiokukoError(error) {
+    return error instanceof KiokukoError;
+}
+function normalizeDatabaseError(error) {
+    if (isKiokukoError(error))
+        throw error;
+    if (error instanceof Error && /unique|constraint/i.test(error.message))
+        conflict();
+    databaseFailure();
+}
+function isPlainObject(value) {
+    try {
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return false;
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
+}
+function isCanonicalArrayIndex(value) {
+    if (value === '0')
+        return true;
+    if (!/^[1-9]\d*$/u.test(value))
+        return false;
+    const index = Number(value);
+    return Number.isSafeInteger(index) && index < 4_294_967_295 && String(index) === value;
+}
+function ownKeys(value) {
+    let keys;
+    try {
+        keys = Reflect.ownKeys(value);
+        if (keys.some((key) => typeof key === 'symbol'))
+            validation();
+        for (const key of keys) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (descriptor === undefined || !('value' in descriptor))
+                validation();
+        }
+    }
+    catch (error) {
+        if (isKiokukoError(error))
+            throw error;
+        validation();
+    }
+    return keys;
+}
+function assertCloneableInput(value) {
+    try {
+        structuredClone(value);
+    }
+    catch {
+        validation();
+    }
+}
+function objectInput(value, fields, requireAll) {
+    if (!isPlainObject(value))
+        validation();
+    const keys = ownKeys(value);
+    assertCloneableInput(value);
+    const allowed = new Set(fields);
+    if (keys.some((key) => !allowed.has(key)))
+        validation();
+    if (requireAll && fields.some((field) => !keys.includes(field)))
+        validation();
+    return value;
+}
+function arrayInput(value) {
+    if (!Array.isArray(value))
+        validation();
+    try {
+        if (Object.getPrototypeOf(value) !== Array.prototype)
+            validation();
+        const keys = ownKeys(value);
+        assertCloneableInput(value);
+        if (!keys.includes('length') || keys.some((key) => key !== 'length' && (!isCanonicalArrayIndex(key) || Number(key) >= value.length)))
+            validation();
+        for (let index = 0; index < value.length; index += 1) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined || !('value' in descriptor))
+                validation();
+        }
+    }
+    catch (error) {
+        if (isKiokukoError(error))
+            throw error;
+        validation();
+    }
+    return value;
+}
+function hasOwn(value, field) {
+    return Object.prototype.hasOwnProperty.call(value, field);
+}
+function readField(value, field) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, field);
+    if (descriptor === undefined || !('value' in descriptor))
+        validation();
+    return descriptor.value;
+}
+function boundedIdentifier(value) {
+    if (typeof value !== 'string' || value.trim().length === 0 || /[\p{C}]/u.test(value) || Buffer.byteLength(value, 'utf8') > MAX_IDENTIFIER_BYTES)
+        validation();
+    return value;
+}
+function boundedStoredIdentifier(value) {
+    if (typeof value !== 'string' || value.trim().length === 0 || /[\p{C}]/u.test(value) || Buffer.byteLength(value, 'utf8') > MAX_IDENTIFIER_BYTES)
+        integrity();
+    return value;
+}
+function nonNegativeSafeInteger(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        validation();
+    return value;
+}
+function positiveSafeInteger(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1)
+        validation();
+    return value;
+}
+function storedNonNegativeSafeInteger(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        integrity();
+    return value;
+}
+function storedPositiveSafeInteger(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1)
+        integrity();
+    return value;
+}
+function hash(value) {
+    if (typeof value !== 'string' || !/^[0-9a-f]{64}$/u.test(value))
+        validation();
+    return value;
+}
+function storedHash(value) {
+    if (typeof value !== 'string' || !/^[0-9a-f]{64}$/u.test(value))
+        integrity();
+    return value;
+}
+function timestamp(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u.test(value))
+        validation();
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== value)
+        validation();
+    return value;
+}
+function storedTimestamp(value) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u.test(value))
+        integrity();
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== value)
+        integrity();
+    return value;
+}
+function booleanValue(value) {
+    if (typeof value !== 'boolean')
+        validation();
+    return value;
+}
+function storedBoolean(value) {
+    if (value !== 0 && value !== 1)
+        integrity();
+    return value === 1;
+}
+function scoreComponents(value) {
+    const object = objectInput(value, CONTEXT_RANKING_COMPONENTS, true);
+    const keys = ownKeys(object);
+    if (keys.length !== CONTEXT_RANKING_COMPONENTS.length || CONTEXT_RANKING_COMPONENTS.some((component) => !keys.includes(component)))
+        validation();
+    const result = {};
+    for (const component of CONTEXT_RANKING_COMPONENTS) {
+        const score = readField(object, component);
+        if (typeof score !== 'number' || !Number.isSafeInteger(score) || !Number.isFinite(score) || score < -MAX_SCORE_COMPONENT || score > MAX_SCORE_COMPONENT)
+            validation();
+        result[component] = score;
+    }
+    return result;
+}
+function storedScoreComponents(value) {
+    try {
+        return scoreComponents(value);
+    }
+    catch {
+        integrity();
+    }
+}
+function selectionReasons(value) {
+    const array = arrayInput(value);
+    if (array.length === 0)
+        validation();
+    const result = [];
+    let previousIndex = -1;
+    for (const item of array) {
+        if (typeof item !== 'string')
+            validation();
+        const reasonIndex = CONTEXT_SELECTION_REASON_ORDER.indexOf(item);
+        if (reasonIndex < 0 || reasonIndex <= previousIndex)
+            validation();
+        previousIndex = reasonIndex;
+        result.push(item);
+    }
+    return result;
+}
+function storedSelectionReasons(value) {
+    try {
+        return selectionReasons(value);
+    }
+    catch {
+        integrity();
+    }
+}
+function validateDeliveryItems(value) {
+    const array = arrayInput(value);
+    if (array.length > MAX_ITEMS)
+        validation();
+    const entries = new Set();
+    return array.map((item, index) => {
+        const object = objectInput(item, ['entryId', 'entryRevision', 'rank', 'scoreComponents', 'selectionReasons'], true);
+        const entryId = boundedIdentifier(readField(object, 'entryId'));
+        if (entries.has(entryId))
+            validation();
+        entries.add(entryId);
+        const entryRevision = positiveSafeInteger(readField(object, 'entryRevision'));
+        const rank = positiveSafeInteger(readField(object, 'rank'));
+        if (rank !== index + 1)
+            validation();
+        return {
+            entryId,
+            entryRevision,
+            rank,
+            scoreComponents: scoreComponents(readField(object, 'scoreComponents')),
+            selectionReasons: selectionReasons(readField(object, 'selectionReasons')),
+        };
+    });
+}
+function sanitizeExternalError(value, workspace) {
+    if (typeof value !== 'string' || value.length === 0)
+        validation();
+    let sanitized;
+    try {
+        sanitized = sanitizeJson({ error: value }, { workspace }).value;
+    }
+    catch {
+        validation();
+    }
+    if (!isPlainObject(sanitized))
+        validation();
+    const error = readField(sanitized, 'error');
+    if (typeof error !== 'string' || error.length === 0 || Buffer.byteLength(error, 'utf8') > MAX_EXTERNAL_ERROR_BYTES)
+        validation();
+    return error;
+}
+function validateExternalSummary(value, workspace) {
+    const object = objectInput(value, ['attempted', 'imported', 'sources'], true);
+    const attempted = booleanValue(readField(object, 'attempted'));
+    const imported = nonNegativeSafeInteger(readField(object, 'imported'));
+    const sourceArray = arrayInput(readField(object, 'sources'));
+    if (sourceArray.length > MAX_SOURCES)
+        validation();
+    const sourceIds = new Set();
+    const sources = sourceArray.map((source) => {
+        const sourceObject = objectInput(source, ['sourceId', 'commit', 'documents', 'imported', 'error'], false);
+        for (const field of ['sourceId', 'commit', 'documents', 'imported']) {
+            if (!hasOwn(sourceObject, field))
+                validation();
+        }
+        const sourceId = boundedIdentifier(readField(sourceObject, 'sourceId'));
+        if (sourceIds.has(sourceId))
+            validation();
+        sourceIds.add(sourceId);
+        const rawCommit = readField(sourceObject, 'commit');
+        const commit = rawCommit === null
+            ? null
+            : typeof rawCommit === 'string' && rawCommit.length > 0 && /^[0-9a-f]+$/u.test(rawCommit) && Buffer.byteLength(rawCommit, 'utf8') <= MAX_IDENTIFIER_BYTES
+                ? rawCommit
+                : validation();
+        const documents = nonNegativeSafeInteger(readField(sourceObject, 'documents'));
+        const sourceImported = nonNegativeSafeInteger(readField(sourceObject, 'imported'));
+        if (sourceImported > documents)
+            validation();
+        const result = { sourceId, commit, documents, imported: sourceImported };
+        if (hasOwn(sourceObject, 'error'))
+            result.error = sanitizeExternalError(readField(sourceObject, 'error'), workspace);
+        return result;
+    });
+    if (!attempted && (imported !== 0 || sources.length !== 0))
+        validation();
+    const sourceTotal = sources.reduce((total, source) => total + source.imported, 0);
+    if (imported !== sourceTotal)
+        validation();
+    const summary = { attempted, imported, sources };
+    if (Buffer.byteLength(canonicalJson(summary), 'utf8') > MAX_EXTERNAL_SUMMARY_BYTES)
+        validation();
+    return summary;
+}
+function validateContextDeliveryInput(value) {
+    try {
+        const object = objectInput(value, [
+            'workspace', 'deliveryId', 'runId', 'throughSequence', 'intakeSessionId', 'taskProfileHash',
+            'queryHash', 'policyVersion', 'externalSyncSummary', 'charBudget', 'charCount', 'truncated',
+            'createdAt', 'items',
+        ], true);
+        const workspace = boundedIdentifier(readField(object, 'workspace'));
+        const deliveryId = boundedIdentifier(readField(object, 'deliveryId'));
+        const runId = boundedIdentifier(readField(object, 'runId'));
+        const throughSequence = nonNegativeSafeInteger(readField(object, 'throughSequence'));
+        const rawIntakeSessionId = readField(object, 'intakeSessionId');
+        const intakeSessionId = rawIntakeSessionId === null ? null : boundedIdentifier(rawIntakeSessionId);
+        const taskProfileHash = hash(readField(object, 'taskProfileHash'));
+        const queryHash = hash(readField(object, 'queryHash'));
+        const policyVersion = boundedIdentifier(readField(object, 'policyVersion'));
+        const externalSyncSummary = validateExternalSummary(readField(object, 'externalSyncSummary'), workspace);
+        const charBudget = readField(object, 'charBudget');
+        if (typeof charBudget !== 'number' || !Number.isSafeInteger(charBudget) || charBudget < 1 || charBudget > MAX_CHAR_BUDGET)
+            validation();
+        const charCount = readField(object, 'charCount');
+        if (typeof charCount !== 'number' || !Number.isSafeInteger(charCount) || charCount < 0 || charCount > charBudget)
+            validation();
+        const truncated = booleanValue(readField(object, 'truncated'));
+        const createdAt = timestamp(readField(object, 'createdAt'));
+        const items = validateDeliveryItems(readField(object, 'items'));
+        return {
+            workspace,
+            deliveryId,
+            runId,
+            throughSequence,
+            intakeSessionId,
+            taskProfileHash,
+            queryHash,
+            policyVersion,
+            externalSyncSummary,
+            charBudget,
+            charCount,
+            truncated,
+            createdAt,
+            items,
+        };
+    }
+    catch {
+        validation();
+    }
+}
+function validateReadInput(value) {
+    try {
+        const object = objectInput(value, ['workspace', 'deliveryId'], true);
+        return {
+            workspace: boundedIdentifier(readField(object, 'workspace')),
+            deliveryId: boundedIdentifier(readField(object, 'deliveryId')),
+        };
+    }
+    catch {
+        validation();
+    }
+}
+function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor), 'utf8').toString('base64url');
+}
+function parseCursor(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        if (typeof value !== 'string' || !/^[A-Za-z0-9_-]+$/u.test(value))
+            validation();
+        const decoded = Buffer.from(value, 'base64url');
+        if (decoded.toString('base64url') !== value)
+            validation();
+        const parsed = JSON.parse(decoded.toString('utf8'));
+        if (!isPlainObject(parsed))
+            validation();
+        const keys = ownKeys(parsed);
+        if (keys.length !== 3 || keys[0] !== 'version' || keys[1] !== 'createdAt' || keys[2] !== 'deliveryId')
+            validation();
+        if (readField(parsed, 'version') !== DELIVERY_CURSOR_VERSION)
+            validation();
+        const createdAt = timestamp(readField(parsed, 'createdAt'));
+        const deliveryId = boundedIdentifier(readField(parsed, 'deliveryId'));
+        const cursor = { version: DELIVERY_CURSOR_VERSION, createdAt, deliveryId };
+        if (encodeCursor(cursor) !== value)
+            validation();
+        return cursor;
+    }
+    catch {
+        validation();
+    }
+}
+function validateListInput(value) {
+    try {
+        const object = objectInput(value, ['workspace', 'runId', 'cursor', 'limit'], false);
+        if (!hasOwn(object, 'workspace') || !hasOwn(object, 'runId'))
+            validation();
+        const workspace = boundedIdentifier(readField(object, 'workspace'));
+        const runId = boundedIdentifier(readField(object, 'runId'));
+        const rawLimit = hasOwn(object, 'limit') ? readField(object, 'limit') : undefined;
+        const limit = rawLimit === undefined ? DEFAULT_LIMIT : rawLimit;
+        if (typeof limit !== 'number' || !Number.isSafeInteger(limit) || limit < 1 || limit > MAX_LIMIT)
+            validation();
+        const cursor = parseCursor(hasOwn(object, 'cursor') ? readField(object, 'cursor') : undefined);
+        return { workspace, runId, limit, ...(cursor === undefined ? {} : { cursor }) };
+    }
+    catch {
+        validation();
+    }
+}
+function canonicalDeliveryBody(input) {
+    return canonicalJson({
+        workspace: input.workspace,
+        deliveryId: input.deliveryId,
+        runId: input.runId,
+        throughSequence: input.throughSequence,
+        intakeSessionId: input.intakeSessionId,
+        taskProfileHash: input.taskProfileHash,
+        queryHash: input.queryHash,
+        policyVersion: input.policyVersion,
+        externalSyncSummary: input.externalSyncSummary,
+        charBudget: input.charBudget,
+        charCount: input.charCount,
+        truncated: input.truncated,
+        createdAt: input.createdAt,
+        items: input.items.map((item) => ({
+            entryId: item.entryId,
+            entryRevision: item.entryRevision,
+            rank: item.rank,
+            scoreComponents: item.scoreComponents,
+            selectionReasons: item.selectionReasons,
+        })),
+    });
+}
+function selectHeaderByDeliveryId(database, deliveryId) {
+    return database.prepare(`
+    SELECT cd.delivery_id, cd.run_id, cd.through_sequence, cd.intake_session_id,
+           cd.task_profile_hash, cd.query_hash, cd.policy_version,
+           cd.external_sync_summary_json, cd.char_budget, cd.char_count,
+           cd.truncated, cd.created_at,
+           lr.workspace AS run_workspace, lr.last_sequence AS run_last_sequence
+      FROM context_deliveries AS cd
+      LEFT JOIN ledger_runs AS lr ON lr.run_id = cd.run_id
+     WHERE cd.delivery_id = ?
+  `).get(deliveryId);
+}
+function assertRunForWrite(database, input) {
+    const run = database.prepare('SELECT run_id, last_sequence FROM ledger_runs WHERE run_id = ? AND workspace = ?').get(input.runId, input.workspace);
+    if (!run)
+        notFound();
+    if (typeof run.run_id !== 'string')
+        integrity();
+    const lastSequence = storedNonNegativeSafeInteger(run.last_sequence);
+    if (input.throughSequence > lastSequence)
+        conflict();
+    if (input.intakeSessionId !== null) {
+        const intake = database.prepare(`
+      SELECT ri.session_id, s.id AS session_id_join, s.workspace AS session_workspace
+        FROM run_intakes AS ri
+        LEFT JOIN akinator_sessions AS s ON s.id = ri.session_id
+       WHERE ri.run_id = ?
+    `).get(input.runId);
+        if (!intake || intake.session_id !== input.intakeSessionId || intake.session_id_join !== input.intakeSessionId || intake.session_workspace !== input.workspace)
+            notFound();
+    }
+    for (const item of input.items) {
+        const entry = database.prepare('SELECT id, workspace, revision FROM entries WHERE id = ?').get(item.entryId);
+        if (!entry || entry.workspace !== input.workspace || entry.id !== item.entryId)
+            notFound();
+        const revision = storedPositiveSafeInteger(entry.revision);
+        if (item.entryRevision > revision)
+            conflict();
+    }
+}
+function validateStoredJson(value) {
+    if (typeof value !== 'string')
+        integrity();
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        integrity();
+    }
+    try {
+        if (canonicalJson(parsed) !== value)
+            integrity();
+    }
+    catch {
+        integrity();
+    }
+    return parsed;
+}
+function validateStoredExternalSummary(value, workspace) {
+    try {
+        const parsed = validateStoredJson(value);
+        const normalized = validateExternalSummary(parsed, workspace);
+        if (canonicalJson(normalized) !== value)
+            integrity();
+        return normalized;
+    }
+    catch (error) {
+        if (isKiokukoError(error) && error.code === 'INTEGRITY_ERROR')
+            throw error;
+        integrity();
+    }
+}
+function validateStoredHeader(row, workspace) {
+    const deliveryId = boundedStoredIdentifier(row.delivery_id);
+    const runId = boundedStoredIdentifier(row.run_id);
+    const runWorkspace = boundedStoredIdentifier(row.run_workspace);
+    if (runWorkspace !== workspace)
+        notFound();
+    const lastSequence = storedNonNegativeSafeInteger(row.run_last_sequence);
+    const throughSequence = storedNonNegativeSafeInteger(row.through_sequence);
+    if (throughSequence > lastSequence)
+        integrity();
+    const rawIntakeSessionId = row.intake_session_id;
+    const intakeSessionId = rawIntakeSessionId === null ? null : boundedStoredIdentifier(rawIntakeSessionId);
+    const taskProfileHash = storedHash(row.task_profile_hash);
+    const queryHash = storedHash(row.query_hash);
+    const policyVersion = boundedStoredIdentifier(row.policy_version);
+    const externalSyncSummary = validateStoredExternalSummary(row.external_sync_summary_json, workspace);
+    const charBudget = storedPositiveSafeInteger(row.char_budget);
+    if (charBudget > MAX_CHAR_BUDGET)
+        integrity();
+    const charCount = storedNonNegativeSafeInteger(row.char_count);
+    if (charCount > charBudget)
+        integrity();
+    const truncated = storedBoolean(row.truncated);
+    const createdAt = storedTimestamp(row.created_at);
+    return {
+        workspace,
+        deliveryId,
+        runId,
+        throughSequence,
+        intakeSessionId,
+        taskProfileHash,
+        queryHash,
+        policyVersion,
+        externalSyncSummary,
+        charBudget,
+        charCount,
+        truncated,
+        createdAt,
+        items: [],
+    };
+}
+function selectDeliveryEntries(database, deliveryId) {
+    return database.prepare(`
+    SELECT cde.delivery_id, cde.entry_id, cde.entry_revision, cde.rank,
+           cde.score_components_json, cde.selection_reason_json,
+           e.workspace AS entry_workspace, e.revision AS current_revision
+      FROM context_delivery_entries AS cde
+      LEFT JOIN entries AS e ON e.id = cde.entry_id
+     WHERE cde.delivery_id = ?
+     ORDER BY cde.rank ASC, cde.entry_id ASC
+  `).all(deliveryId);
+}
+function validateStoredEntries(database, header) {
+    const rows = selectDeliveryEntries(database, header.deliveryId);
+    if (rows.length > MAX_ITEMS)
+        integrity();
+    const entryIds = new Set();
+    let expectedRank = 1;
+    return rows.map((row) => {
+        const deliveryId = boundedStoredIdentifier(row.delivery_id);
+        const entryId = boundedStoredIdentifier(row.entry_id);
+        if (deliveryId !== header.deliveryId || entryIds.has(entryId))
+            integrity();
+        entryIds.add(entryId);
+        const entryWorkspace = boundedStoredIdentifier(row.entry_workspace);
+        if (entryWorkspace !== header.workspace)
+            integrity();
+        const currentRevision = storedPositiveSafeInteger(row.current_revision);
+        const entryRevision = storedPositiveSafeInteger(row.entry_revision);
+        if (entryRevision > currentRevision)
+            integrity();
+        const rank = storedPositiveSafeInteger(row.rank);
+        if (rank !== expectedRank)
+            integrity();
+        expectedRank += 1;
+        const scoreValue = validateStoredJson(row.score_components_json);
+        const reasonValue = validateStoredJson(row.selection_reason_json);
+        const score = storedScoreComponents(scoreValue);
+        const reasons = storedSelectionReasons(reasonValue);
+        if (canonicalJson(score) !== row.score_components_json || canonicalJson(reasons) !== row.selection_reason_json)
+            integrity();
+        return { entryId, entryRevision, rank, scoreComponents: score, selectionReasons: reasons };
+    });
+}
+function assertStoredIntakeLink(database, header) {
+    if (header.intakeSessionId === null)
+        return;
+    const intake = database.prepare(`
+    SELECT ri.run_id, ri.session_id, s.id AS session_id_join, s.workspace AS session_workspace
+      FROM run_intakes AS ri
+      LEFT JOIN akinator_sessions AS s ON s.id = ri.session_id
+     WHERE ri.run_id = ?
+  `).get(header.runId);
+    if (!intake || intake.run_id !== header.runId || intake.session_id !== header.intakeSessionId || intake.session_id_join !== header.intakeSessionId || intake.session_workspace !== header.workspace)
+        integrity();
+}
+function readStoredDelivery(database, workspace, deliveryId) {
+    const row = selectHeaderByDeliveryId(database, deliveryId);
+    if (!row)
+        notFound();
+    if (row.run_workspace === null || row.run_workspace === undefined)
+        integrity();
+    if (row.run_workspace !== workspace)
+        notFound();
+    const header = validateStoredHeader(row, workspace);
+    assertStoredIntakeLink(database, header);
+    const items = validateStoredEntries(database, header);
+    const view = {
+        ...header,
+        items: items.map((item) => ({ ...item, scoreComponents: { ...item.scoreComponents }, selectionReasons: [...item.selectionReasons], untrusted: true })),
+        untrusted: true,
+    };
+    return view;
+}
+function writeContextDelivery(database, input) {
+    const existing = selectHeaderByDeliveryId(database, input.deliveryId);
+    if (existing) {
+        if (existing.run_workspace !== input.workspace)
+            conflict();
+        const stored = readStoredDelivery(database, input.workspace, input.deliveryId);
+        if (canonicalDeliveryBody(stored) === canonicalDeliveryBody(input))
+            return stored;
+        conflict();
+    }
+    assertRunForWrite(database, input);
+    const summaryJson = canonicalJson(input.externalSyncSummary);
+    database.prepare(`
+    INSERT INTO context_deliveries (
+      delivery_id, run_id, through_sequence, intake_session_id, task_profile_hash, query_hash,
+      policy_version, external_sync_summary_json, char_budget, char_count, truncated, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(input.deliveryId, input.runId, input.throughSequence, input.intakeSessionId, input.taskProfileHash, input.queryHash, input.policyVersion, summaryJson, input.charBudget, input.charCount, input.truncated ? 1 : 0, input.createdAt);
+    for (const item of input.items) {
+        database.prepare(`
+      INSERT INTO context_delivery_entries (
+        delivery_id, entry_id, entry_revision, rank, score_components_json, selection_reason_json
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `).run(input.deliveryId, item.entryId, item.entryRevision, item.rank, canonicalJson(item.scoreComponents), canonicalJson(item.selectionReasons));
+    }
+    return readStoredDelivery(database, input.workspace, input.deliveryId);
+}
+export function recordContextDeliveryInTransaction(database, input) {
+    const validated = validateContextDeliveryInput(input);
+    try {
+        return writeContextDelivery(database, validated);
+    }
+    catch (error) {
+        normalizeDatabaseError(error);
+    }
+}
+export function recordContextDelivery(database, input) {
+    const validated = validateContextDeliveryInput(input);
+    try {
+        return withImmediateTransaction(database, () => writeContextDelivery(database, validated));
+    }
+    catch (error) {
+        normalizeDatabaseError(error);
+    }
+}
+export function readContextDelivery(database, input) {
+    const validated = validateReadInput(input);
+    try {
+        return readStoredDelivery(database, validated.workspace, validated.deliveryId);
+    }
+    catch (error) {
+        normalizeDatabaseError(error);
+    }
+}
+export function listContextDeliveries(database, input) {
+    const validated = validateListInput(input);
+    try {
+        const run = database.prepare('SELECT run_id, workspace, last_sequence FROM ledger_runs WHERE run_id = ? AND workspace = ?').get(validated.runId, validated.workspace);
+        if (!run)
+            notFound();
+        if (run.run_id !== validated.runId || run.workspace !== validated.workspace)
+            integrity();
+        storedNonNegativeSafeInteger(run.last_sequence);
+        const parameters = [validated.runId, validated.workspace];
+        let cursorClause = '';
+        if (validated.cursor !== undefined) {
+            cursorClause = ' AND (cd.created_at < ? OR (cd.created_at = ? AND cd.delivery_id > ?))';
+            parameters.push(validated.cursor.createdAt, validated.cursor.createdAt, validated.cursor.deliveryId);
+        }
+        parameters.push(validated.limit + 1);
+        const rows = database.prepare(`
+      SELECT cd.delivery_id, cd.run_id, cd.through_sequence, cd.intake_session_id,
+             cd.task_profile_hash, cd.query_hash, cd.policy_version,
+             cd.external_sync_summary_json, cd.char_budget, cd.char_count,
+             cd.truncated, cd.created_at,
+             lr.workspace AS run_workspace, lr.last_sequence AS run_last_sequence
+        FROM context_deliveries AS cd
+        LEFT JOIN ledger_runs AS lr ON lr.run_id = cd.run_id
+       WHERE cd.run_id = ? AND lr.workspace = ?${cursorClause}
+       ORDER BY cd.created_at DESC, cd.delivery_id ASC
+       LIMIT ?
+    `).all(...parameters);
+        const pageRows = rows.slice(0, validated.limit);
+        const items = pageRows.map((row) => {
+            const header = validateStoredHeader(row, validated.workspace);
+            assertStoredIntakeLink(database, header);
+            const storedItems = validateStoredEntries(database, header);
+            return {
+                ...header,
+                items: storedItems.map((item) => ({ ...item, scoreComponents: { ...item.scoreComponents }, selectionReasons: [...item.selectionReasons], untrusted: true })),
+                untrusted: true,
+            };
+        });
+        const last = pageRows.at(-1);
+        const nextCursor = rows.length > validated.limit && last !== undefined
+            ? encodeCursor({ version: DELIVERY_CURSOR_VERSION, createdAt: storedTimestamp(last.created_at), deliveryId: boundedStoredIdentifier(last.delivery_id) })
+            : null;
+        return { items, nextCursor };
+    }
+    catch (error) {
+        normalizeDatabaseError(error);
+    }
+}
+//# sourceMappingURL=delivery.js.map