@kya-os/mcp-i-cloudflare 1.12.3 → 1.13.0

package/dist/audit/durable-producer.js

@@ -0,0 +1,953 @@
+import { canonicalize } from "json-canonicalize";
+import { CompactJwsAuditSignatureVerifier, CryptoProviderAuditHasher, createAuditTrail, parseAuditProducerEvent, parseSignedAuditEntry, } from "@kya-os/mcp/audit";
+import { WebCryptoProvider } from "../providers/crypto";
+import { VerifiedAuditRecorderClient } from "./verified-recorder-client";
+const INTERNAL_ORIGIN = "https://audit-producer.internal";
+const INTERNAL_TOKEN_HEADER = "x-kya-audit-internal-token";
+const MAX_ERROR_LENGTH = 512;
+const MAX_INSPECTION_LIMIT = 100;
+export const AUDIT_PRODUCER_BINDING = "AUDIT_PRODUCER";
+export const AUDIT_PRODUCER_CLASS_NAME = "AuditProducer";
+class SourceConstructionPendingError extends Error {
+    constructor(sourceId) {
+        super(`Previous audit source event for ${sourceId} has not finished construction`);
+        this.name = "SourceConstructionPendingError";
+    }
+}
+class AuditProducerRequestError extends Error {
+    status;
+    constructor(status, detail) {
+        super(`Audit producer request failed: ${detail}`);
+        this.status = status;
+        this.name = "AuditProducerRequestError";
+    }
+}
+function boundedInteger(value, fallback, minimum, maximum) {
+    if (value === undefined || !/^\d+$/.test(value))
+        return fallback;
+    return Math.min(maximum, Math.max(minimum, Number(value)));
+}
+export function resolveAuditProducerRetryPolicy(env) {
+    const baseDelayMs = boundedInteger(env.KYA_OS_AUDIT_RETRY_BASE_MS, 1_000, 250, 60_000);
+    return {
+        maxAttempts: boundedInteger(env.KYA_OS_AUDIT_MAX_ATTEMPTS, 8, 1, 20),
+        baseDelayMs,
+        maxDelayMs: boundedInteger(env.KYA_OS_AUDIT_RETRY_MAX_MS, 300_000, baseDelayMs, 86_400_000),
+        batchSize: boundedInteger(env.KYA_OS_AUDIT_DELIVERY_BATCH_SIZE, 25, 1, 100),
+        deadLetterRetentionMs: boundedInteger(env.KYA_OS_AUDIT_DEAD_LETTER_RETENTION_MS, 30 * 86_400_000, 3_600_000, 90 * 86_400_000),
+        receiptRetentionMs: boundedInteger(env.KYA_OS_AUDIT_RECEIPT_RETENTION_MS, 30 * 86_400_000, 3_600_000, 90 * 86_400_000),
+    };
+}
+export function auditRetryDelayMs(attempts, policy) {
+    const exponent = Math.max(0, Math.min(30, attempts - 1));
+    return Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** exponent);
+}
+function errorMessage(error) {
+    const value = error instanceof Error ? error.message : String(error);
+    return value.slice(0, MAX_ERROR_LENGTH);
+}
+function bytesToBase64(value) {
+    let binary = "";
+    for (let offset = 0; offset < value.byteLength; offset += 0x8000) {
+        binary += String.fromCharCode(...value.subarray(offset, offset + 0x8000));
+    }
+    return btoa(binary);
+}
+function base64ToBytes(value) {
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {
+        throw new TypeError("Audit evidence ciphertext is not valid base64");
+    }
+    const binary = atob(value);
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function toWireSubmission(submission) {
+    return {
+        ledgerId: submission.ledgerId,
+        ...(submission.expectedLedgerEpochId === undefined
+            ? {}
+            : { expectedLedgerEpochId: submission.expectedLedgerEpochId }),
+        producerEvent: submission.producerEvent,
+        encryptedEvidence: submission.encryptedEvidence.map((item) => ({
+            ref: item.ref,
+            ciphertextBase64: bytesToBase64(item.ciphertext),
+        })),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseWireSubmission(value) {
+    if (!isRecord(value) ||
+        typeof value.ledgerId !== "string" ||
+        value.ledgerId.trim() === "") {
+        throw new TypeError("Audit recorder submission ledgerId is required");
+    }
+    if (value.expectedLedgerEpochId !== undefined &&
+        typeof value.expectedLedgerEpochId !== "string") {
+        throw new TypeError("Audit recorder expectedLedgerEpochId must be a string");
+    }
+    if (!Array.isArray(value.encryptedEvidence)) {
+        throw new TypeError("Audit recorder encryptedEvidence must be an array");
+    }
+    const encryptedEvidence = value.encryptedEvidence.map((candidate) => {
+        if (!isRecord(candidate) ||
+            !isRecord(candidate.ref) ||
+            typeof candidate.ciphertextBase64 !== "string") {
+            throw new TypeError("Audit recorder encrypted evidence is malformed");
+        }
+        return {
+            ref: candidate.ref,
+            ciphertext: base64ToBytes(candidate.ciphertextBase64),
+        };
+    });
+    return {
+        ledgerId: value.ledgerId,
+        ...(value.expectedLedgerEpochId === undefined
+            ? {}
+            : { expectedLedgerEpochId: value.expectedLedgerEpochId }),
+        producerEvent: parseAuditProducerEvent(value.producerEvent),
+        encryptedEvidence,
+    };
+}
+function toWireItem(item) {
+    return {
+        eventId: item.eventId,
+        submission: toWireSubmission(item.submission),
+        enqueuedAt: item.enqueuedAt,
+        attempts: item.attempts,
+    };
+}
+function parseWireItem(value) {
+    if (!isRecord(value) ||
+        typeof value.eventId !== "string" ||
+        !Number.isFinite(value.enqueuedAt) ||
+        !Number.isInteger(value.attempts) ||
+        Number(value.attempts) < 0) {
+        throw new TypeError("Audit outbox item is malformed");
+    }
+    const submission = parseWireSubmission(value.submission);
+    if (submission.producerEvent.eventId !== value.eventId) {
+        throw new TypeError("Audit outbox eventId does not match its frozen event");
+    }
+    return {
+        eventId: value.eventId,
+        submission,
+        enqueuedAt: Number(value.enqueuedAt),
+        attempts: Number(value.attempts),
+    };
+}
+function parseDelivery(value) {
+    if (value !== "best-effort" && value !== "buffered" && value !== "required") {
+        throw new TypeError("Unknown audit delivery mode");
+    }
+    return value;
+}
+function json(value, status = 200) {
+    return new Response(JSON.stringify(value), {
+        status,
+        headers: { "Content-Type": "application/json; charset=utf-8" },
+    });
+}
+function problem(status, code, detail) {
+    return json({
+        type: `urn:kya-os:problem:${code.toLowerCase()}`,
+        title: code,
+        status,
+        detail,
+    }, status);
+}
+function sameSigner(left, right) {
+    return (left.did === right.did && left.kid === right.kid && left.alg === right.alg);
+}
+function requiredEnv(env, key) {
+    const value = env[key];
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`Audit producer is not configured: ${String(key)} is required`);
+    }
+    return value;
+}
+function recorderTrustFromConfig(env) {
+    let config;
+    try {
+        config = JSON.parse(requiredEnv(env, "KYA_OS_AUDIT_CONFIG"));
+    }
+    catch (error) {
+        throw new Error(`KYA_OS_AUDIT_CONFIG is invalid: ${errorMessage(error)}`);
+    }
+    if (!isRecord(config) ||
+        !isRecord(config.recorderSigner) ||
+        !isRecord(config.recorderPublicJwk)) {
+        throw new Error("KYA_OS_AUDIT_CONFIG must contain recorderSigner and recorderPublicJwk");
+    }
+    const signer = config.recorderSigner;
+    if (typeof signer.did !== "string" ||
+        typeof signer.kid !== "string" ||
+        (signer.alg !== "EdDSA" && signer.alg !== "ES256")) {
+        throw new Error("KYA_OS_AUDIT_CONFIG recorderSigner is malformed");
+    }
+    if (typeof config.recorderPublicJwk.kty !== "string") {
+        throw new Error("KYA_OS_AUDIT_CONFIG recorderPublicJwk is malformed");
+    }
+    return {
+        expectedRecorder: { did: signer.did, kid: signer.kid, alg: signer.alg },
+        key: config.recorderPublicJwk,
+    };
+}
+function buildVerifiedRecorder(env) {
+    const { expectedRecorder, key } = recorderTrustFromConfig(env);
+    const verifier = new CompactJwsAuditSignatureVerifier({
+        resolve: async (signer) => sameSigner(signer, expectedRecorder) ? key : null,
+    });
+    return new VerifiedAuditRecorderClient({
+        endpoint: requiredEnv(env, "KYA_OS_AUDIT_RECORDER_URL"),
+        ...(env.KYA_OS_AUDIT_RECORDER_SERVICE === undefined
+            ? {}
+            : { transport: env.KYA_OS_AUDIT_RECORDER_SERVICE }),
+        ...(env.KYA_OS_AUDIT_INGEST_KEY === undefined
+            ? {}
+            : {
+                headers: { Authorization: `Bearer ${env.KYA_OS_AUDIT_INGEST_KEY}` },
+            }),
+        hasher: new CryptoProviderAuditHasher(new WebCryptoProvider()),
+        signatureVerifier: verifier,
+        expectedRecorder,
+    });
+}
+/** Pure delivery coordinator; persistence and alarms are injected for deterministic tests. */
+export class AuditProducerDeliveryEngine {
+    store;
+    recorder;
+    alarms;
+    policy;
+    clock;
+    constructor(store, recorder, alarms, policy, clock = { now: () => Date.now() }) {
+        this.store = store;
+        this.recorder = recorder;
+        this.alarms = alarms;
+        this.policy = policy;
+        this.clock = clock;
+    }
+    async enqueue(item) {
+        const now = this.clock.now();
+        this.store.enqueue(item, now);
+        await this.alarms.setAlarm(now + 1);
+    }
+    async flush() {
+        let delivered = 0;
+        let failed = 0;
+        let deadLettered = 0;
+        const blockedSources = new Set();
+        this.store.prune(this.clock.now(), this.policy);
+        while (delivered + failed < this.policy.batchSize) {
+            const items = this.store.pending(this.clock.now(), this.policy.batchSize - delivered - failed, blockedSources);
+            if (items.length === 0)
+                break;
+            for (const item of items) {
+                const sourceId = item.submission.producerEvent.source.sourceId;
+                try {
+                    const entry = await this.recorder().submit(item.submission);
+                    this.store.markDelivered(item.eventId, entry, this.clock.now());
+                    delivered += 1;
+                }
+                catch (error) {
+                    const outcome = this.store.markFailed(item.eventId, error, this.clock.now(), this.policy);
+                    blockedSources.add(sourceId);
+                    failed += 1;
+                    if (outcome.state === "dead")
+                        deadLettered += 1;
+                }
+                if (delivered + failed >= this.policy.batchSize)
+                    break;
+            }
+        }
+        await this.scheduleNext();
+        return { delivered, failed, deadLettered };
+    }
+    async scheduleNext() {
+        const now = this.clock.now();
+        const next = this.store.nextAlarmAt(now, this.policy);
+        if (next === null) {
+            await this.alarms.deleteAlarm();
+            return;
+        }
+        await this.alarms.setAlarm(Math.max(now + 1, next));
+    }
+}
+class SqliteAuditProducerStore {
+    state;
+    sql;
+    constructor(state) {
+        this.state = state;
+        this.sql = state.storage.sql;
+    }
+    initialize() {
+        this.sql.exec(`CREATE TABLE IF NOT EXISTS audit_outbox (
+      enqueue_order INTEGER PRIMARY KEY AUTOINCREMENT,
+      event_id TEXT NOT NULL UNIQUE,
+      source_id TEXT NOT NULL,
+      source_sequence TEXT,
+      submission_json TEXT NOT NULL,
+      enqueued_at INTEGER NOT NULL,
+      attempts INTEGER NOT NULL,
+      available_at INTEGER NOT NULL,
+      state TEXT NOT NULL CHECK (state IN ('pending', 'delivered', 'dead')),
+      last_error TEXT,
+      dead_lettered_at INTEGER,
+      updated_at INTEGER NOT NULL
+    )`);
+        this.sql.exec("CREATE INDEX IF NOT EXISTS audit_outbox_due ON audit_outbox(state, available_at, enqueue_order)");
+        this.sql.exec("CREATE INDEX IF NOT EXISTS audit_outbox_source ON audit_outbox(source_id, enqueue_order)");
+        this.sql.exec(`CREATE TABLE IF NOT EXISTS audit_receipts (
+      event_id TEXT PRIMARY KEY,
+      entry_json TEXT NOT NULL,
+      entry_digest TEXT NOT NULL,
+      recorded_at INTEGER NOT NULL,
+      received_at INTEGER NOT NULL
+    )`);
+        this.sql.exec(`CREATE TABLE IF NOT EXISTS audit_source_heads (
+      source_id TEXT PRIMARY KEY,
+      next_sequence TEXT NOT NULL,
+      receipted_watermark TEXT NOT NULL,
+      last_event_digest TEXT
+    )`);
+        this.sql.exec(`CREATE TABLE IF NOT EXISTS audit_source_claims (
+      source_id TEXT NOT NULL,
+      event_id TEXT NOT NULL,
+      sequence TEXT NOT NULL,
+      previous_event_digest TEXT,
+      event_digest TEXT,
+      receipt_digest TEXT,
+      PRIMARY KEY (source_id, event_id),
+      UNIQUE (source_id, sequence)
+    )`);
+    }
+    enqueue(item, now) {
+        const submissionJson = canonicalize(toWireSubmission(item.submission));
+        const existing = this.sql
+            .exec("SELECT submission_json FROM audit_outbox WHERE event_id = ?", item.eventId)
+            .toArray()[0];
+        if (existing !== undefined) {
+            if (existing.submission_json !== submissionJson) {
+                throw new Error(`Audit outbox event identity collision: ${item.eventId}`);
+            }
+            return;
+        }
+        this.sql.exec(`INSERT INTO audit_outbox (
+        event_id, source_id, source_sequence, submission_json, enqueued_at,
+        attempts, available_at, state, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?)`, item.eventId, item.submission.producerEvent.source.sourceId, item.submission.producerEvent.source.sourceSequence ?? null, submissionJson, item.enqueuedAt, item.attempts, now, now);
+    }
+    pending(now, limit, blockedSources) {
+        const rows = this.sql
+            .exec(`SELECT current.event_id, current.submission_json, current.enqueued_at,
+              current.attempts, current.available_at, current.source_id
+       FROM audit_outbox current
+       WHERE current.state = 'pending' AND current.available_at <= ?
+         AND NOT EXISTS (
+           SELECT 1 FROM audit_outbox earlier
+           WHERE earlier.source_id = current.source_id
+             AND earlier.state = 'pending'
+             AND earlier.enqueue_order < current.enqueue_order
+         )
+       ORDER BY current.enqueue_order ASC
+       LIMIT 1000`, now)
+            .toArray();
+        const result = [];
+        for (const row of rows) {
+            if (blockedSources.has(row.source_id))
+                continue;
+            result.push({
+                eventId: row.event_id,
+                submission: parseWireSubmission(JSON.parse(row.submission_json)),
+                enqueuedAt: row.enqueued_at,
+                attempts: row.attempts,
+                availableAt: row.available_at,
+            });
+            if (result.length >= limit)
+                break;
+        }
+        return result;
+    }
+    saveReceipt(eventId, entry, now) {
+        this.sql.exec(`INSERT INTO audit_receipts (event_id, entry_json, entry_digest, recorded_at, received_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(event_id) DO UPDATE SET
+         entry_json = excluded.entry_json,
+         entry_digest = excluded.entry_digest,
+         recorded_at = excluded.recorded_at,
+         received_at = excluded.received_at`, eventId, canonicalize(entry), entry.entryDigest, entry.core.recordedAt, now);
+    }
+    markDelivered(eventId, entry, now) {
+        const outbox = this.sql
+            .exec("SELECT source_id, source_sequence FROM audit_outbox WHERE event_id = ?", eventId)
+            .toArray()[0];
+        this.state.storage.transactionSync(() => {
+            this.saveReceipt(eventId, entry, now);
+            this.sql.exec("UPDATE audit_outbox SET state = 'delivered', last_error = NULL, updated_at = ? WHERE event_id = ?", now, eventId);
+        });
+        // Alarm delivery bypasses AuditTrailService.flush(), so advance the same
+        // durable source watermark here after the authoritative receipt is saved.
+        if (outbox?.source_sequence !== null &&
+            outbox?.source_sequence !== undefined) {
+            try {
+                this.markReceipted(outbox.source_id, outbox.source_sequence, entry.entryDigest);
+            }
+            catch (error) {
+                // The recorder commit is authoritative. Preserve the local reconciliation
+                // failure without relabelling a verified delivery as failed/retryable.
+                this.sql.exec("UPDATE audit_outbox SET last_error = ? WHERE event_id = ?", `SOURCE_STATE: ${errorMessage(error)}`, eventId);
+            }
+        }
+    }
+    markDeliveredFromReceipt(eventId, now) {
+        if (this.receipt(eventId) === undefined)
+            return false;
+        this.sql.exec("UPDATE audit_outbox SET state = 'delivered', last_error = NULL, updated_at = ? WHERE event_id = ?", now, eventId);
+        return (this.sql
+            .exec("SELECT state FROM audit_outbox WHERE event_id = ?", eventId)
+            .toArray()[0]?.state === "delivered");
+    }
+    markFailed(eventId, error, now, policy) {
+        const row = this.sql
+            .exec("SELECT attempts, state FROM audit_outbox WHERE event_id = ?", eventId)
+            .toArray()[0];
+        if (row === undefined || row.state !== "pending") {
+            throw new RangeError(`Unknown pending audit outbox item: ${eventId}`);
+        }
+        const attempts = row.attempts + 1;
+        if (attempts >= policy.maxAttempts) {
+            this.sql.exec(`UPDATE audit_outbox SET attempts = ?, state = 'dead', last_error = ?,
+           dead_lettered_at = ?, updated_at = ? WHERE event_id = ?`, attempts, errorMessage(error), now, now, eventId);
+            return { state: "dead", attempts };
+        }
+        const availableAt = now + auditRetryDelayMs(attempts, policy);
+        this.sql.exec(`UPDATE audit_outbox SET attempts = ?, available_at = ?, last_error = ?,
+         updated_at = ? WHERE event_id = ?`, attempts, availableAt, errorMessage(error), now, eventId);
+        return { state: "pending", attempts, availableAt };
+    }
+    nextAlarmAt(_now, policy) {
+        const pending = this.sql
+            .exec("SELECT MIN(available_at) AS value FROM audit_outbox WHERE state = 'pending'")
+            .toArray()[0]?.value;
+        const dead = this.sql
+            .exec("SELECT MIN(dead_lettered_at) AS value FROM audit_outbox WHERE state = 'dead'")
+            .toArray()[0]?.value;
+        const receipt = this.sql
+            .exec("SELECT MIN(received_at) AS value FROM audit_receipts")
+            .toArray()[0]?.value;
+        const candidates = [
+            pending,
+            dead === null || dead === undefined
+                ? null
+                : dead + policy.deadLetterRetentionMs,
+            receipt === null || receipt === undefined
+                ? null
+                : receipt + policy.receiptRetentionMs,
+        ].filter((value) => value !== null && value !== undefined);
+        return candidates.length === 0 ? null : Math.min(...candidates);
+    }
+    prune(now, policy) {
+        this.state.storage.transactionSync(() => {
+            this.sql.exec("DELETE FROM audit_outbox WHERE state = 'dead' AND dead_lettered_at < ?", now - policy.deadLetterRetentionMs);
+            this.sql.exec("DELETE FROM audit_outbox WHERE state = 'delivered' AND updated_at < ?", now - policy.receiptRetentionMs);
+            this.sql.exec("DELETE FROM audit_receipts WHERE received_at < ?", now - policy.receiptRetentionMs);
+        });
+    }
+    deadLetters(limit) {
+        return this.sql
+            .exec(`SELECT event_id, source_id, source_sequence, attempts, enqueued_at,
+              dead_lettered_at, last_error
+       FROM audit_outbox WHERE state = 'dead'
+       ORDER BY dead_lettered_at DESC LIMIT ?`, limit)
+            .toArray()
+            .map((row) => ({
+            eventId: row.event_id,
+            sourceId: row.source_id,
+            ...(row.source_sequence === null
+                ? {}
+                : { sourceSequence: row.source_sequence }),
+            attempts: row.attempts,
+            enqueuedAt: row.enqueued_at,
+            deadLetteredAt: row.dead_lettered_at,
+            lastError: row.last_error,
+        }));
+    }
+    redrive(eventId, now) {
+        this.sql.exec(`UPDATE audit_outbox SET state = 'pending', attempts = 0, available_at = ?,
+         last_error = NULL, dead_lettered_at = NULL, updated_at = ?
+       WHERE event_id = ? AND state = 'dead'`, now, now, eventId);
+        return (this.sql
+            .exec("SELECT state FROM audit_outbox WHERE event_id = ?", eventId)
+            .toArray()[0]?.state === "pending");
+    }
+    receipt(eventId) {
+        const row = this.sql
+            .exec("SELECT entry_json FROM audit_receipts WHERE event_id = ?", eventId)
+            .toArray()[0];
+        return row === undefined
+            ? undefined
+            : parseSignedAuditEntry(JSON.parse(row.entry_json));
+    }
+    claimEvent(sourceId, eventId) {
+        return this.state.storage.transactionSync(() => {
+            const existing = this.sql
+                .exec("SELECT sequence, previous_event_digest FROM audit_source_claims WHERE source_id = ? AND event_id = ?", sourceId, eventId)
+                .toArray()[0];
+            if (existing !== undefined) {
+                return {
+                    sequence: existing.sequence,
+                    ...(existing.previous_event_digest === null
+                        ? {}
+                        : {
+                            previousSourceEventDigest: existing.previous_event_digest,
+                        }),
+                };
+            }
+            const head = this.sql
+                .exec("SELECT next_sequence, last_event_digest FROM audit_source_heads WHERE source_id = ?", sourceId)
+                .toArray()[0];
+            if (head !== undefined) {
+                const current = this.sql
+                    .exec("SELECT event_digest FROM audit_source_claims WHERE source_id = ? AND sequence = ?", sourceId, head.next_sequence)
+                    .toArray()[0];
+                if (current?.event_digest === null) {
+                    throw new SourceConstructionPendingError(sourceId);
+                }
+            }
+            const sequence = (BigInt(head?.next_sequence ?? "0") + 1n).toString();
+            const previous = head?.last_event_digest ?? null;
+            this.sql.exec(`INSERT INTO audit_source_heads (source_id, next_sequence, receipted_watermark, last_event_digest)
+         VALUES (?, ?, '0', ?)
+         ON CONFLICT(source_id) DO UPDATE SET next_sequence = excluded.next_sequence`, sourceId, sequence, previous);
+            this.sql.exec(`INSERT INTO audit_source_claims
+         (source_id, event_id, sequence, previous_event_digest)
+         VALUES (?, ?, ?, ?)`, sourceId, eventId, sequence, previous);
+            return {
+                sequence,
+                ...(previous === null
+                    ? {}
+                    : { previousSourceEventDigest: previous }),
+            };
+        });
+    }
+    markEmitted(sourceId, eventId, sequence, eventDigest) {
+        this.state.storage.transactionSync(() => {
+            const claim = this.sql
+                .exec("SELECT sequence, event_digest FROM audit_source_claims WHERE source_id = ? AND event_id = ?", sourceId, eventId)
+                .toArray()[0];
+            if (claim === undefined || claim.sequence !== sequence) {
+                throw new RangeError("Unknown source event claim");
+            }
+            if (claim.event_digest !== null && claim.event_digest !== eventDigest) {
+                throw new Error(`Source event identity collision: ${eventId}`);
+            }
+            this.sql.exec("UPDATE audit_source_claims SET event_digest = ? WHERE source_id = ? AND event_id = ?", eventDigest, sourceId, eventId);
+            this.sql.exec("UPDATE audit_source_heads SET last_event_digest = ? WHERE source_id = ? AND next_sequence = ?", eventDigest, sourceId, sequence);
+        });
+    }
+    markReceipted(sourceId, sequence, entryDigest) {
+        this.state.storage.transactionSync(() => {
+            const claim = this.sql
+                .exec("SELECT event_id FROM audit_source_claims WHERE source_id = ? AND sequence = ?", sourceId, sequence)
+                .toArray()[0];
+            if (claim === undefined)
+                throw new RangeError("Unknown source sequence");
+            this.sql.exec("UPDATE audit_source_claims SET receipt_digest = ? WHERE source_id = ? AND sequence = ?", entryDigest, sourceId, sequence);
+            const head = this.sql
+                .exec("SELECT receipted_watermark FROM audit_source_heads WHERE source_id = ?", sourceId)
+                .toArray()[0];
+            let watermark = BigInt(head?.receipted_watermark ?? "0");
+            const receipted = new Set(this.sql
+                .exec("SELECT sequence FROM audit_source_claims WHERE source_id = ? AND receipt_digest IS NOT NULL", sourceId)
+                .toArray()
+                .map((row) => row.sequence));
+            while (receipted.has((watermark + 1n).toString()))
+                watermark += 1n;
+            this.sql.exec("UPDATE audit_source_heads SET receipted_watermark = ? WHERE source_id = ?", watermark.toString(), sourceId);
+            for (const row of this.sql
+                .exec("SELECT event_id, sequence FROM audit_source_claims WHERE source_id = ?", sourceId)
+                .toArray()) {
+                if (BigInt(row.sequence) < watermark) {
+                    this.sql.exec("DELETE FROM audit_source_claims WHERE source_id = ? AND event_id = ?", sourceId, row.event_id);
+                }
+            }
+        });
+    }
+    getSourceState(sourceId) {
+        const head = this.sql
+            .exec("SELECT next_sequence, receipted_watermark FROM audit_source_heads WHERE source_id = ?", sourceId)
+            .toArray()[0];
+        if (head === undefined) {
+            return {
+                sourceId,
+                highestEmitted: "0",
+                highestReceipted: "0",
+                pendingSequences: [],
+            };
+        }
+        const pendingSequences = this.sql
+            .exec("SELECT sequence FROM audit_source_claims WHERE source_id = ? AND receipt_digest IS NULL", sourceId)
+            .toArray()
+            .map((row) => row.sequence)
+            .sort((left, right) => {
+            const a = BigInt(left);
+            const b = BigInt(right);
+            return a < b ? -1 : a > b ? 1 : 0;
+        });
+        return {
+            sourceId,
+            highestEmitted: head.next_sequence,
+            highestReceipted: head.receipted_watermark,
+            pendingSequences,
+        };
+    }
+}
+function constantTimeTokenEqual(expected, actual) {
+    if (actual === null)
+        return false;
+    const left = new TextEncoder().encode(expected);
+    const right = new TextEncoder().encode(actual);
+    let difference = left.byteLength ^ right.byteLength;
+    const length = Math.max(left.byteLength, right.byteLength);
+    for (let index = 0; index < length; index += 1) {
+        difference |= (left[index] ?? 0) ^ (right[index] ?? 0);
+    }
+    return difference === 0;
+}
+/**
+ * SQLite-backed producer boundary. It is deliberately separate from the MCP
+ * agent Durable Object, so recorder latency and retry alarms cannot mutate or
+ * stall authorization, consent, delegation, or session state.
+ */
+export class AuditProducer {
+    state;
+    env;
+    store;
+    policy;
+    delivery;
+    ready;
+    recorderClient;
+    constructor(state, env) {
+        this.state = state;
+        this.env = env;
+        this.store = new SqliteAuditProducerStore(state);
+        this.policy = resolveAuditProducerRetryPolicy(env);
+        this.ready = state.blockConcurrencyWhile(async () => this.store.initialize());
+        this.delivery = new AuditProducerDeliveryEngine(this.store, () => this.recorder(), state.storage, this.policy);
+    }
+    async fetch(request) {
+        await this.ready;
+        const expectedInternalToken = this.env.KYA_OS_AUDIT_PRODUCER_INTERNAL_TOKEN;
+        if (typeof expectedInternalToken !== "string" ||
+            expectedInternalToken.trim().length === 0) {
+            return problem(503, "AUDIT_PRODUCER_MISCONFIGURED", "Internal audit producer authentication is not configured");
+        }
+        if (!constantTimeTokenEqual(expectedInternalToken, request.headers.get(INTERNAL_TOKEN_HEADER))) {
+            return problem(401, "AUDIT_PRODUCER_UNAUTHORIZED", "Invalid internal audit producer token");
+        }
+        const url = new URL(request.url);
+        try {
+            if (request.method === "POST" && url.pathname === "/v1/record") {
+                const body = await request.json();
+                if (!isRecord(body))
+                    throw new TypeError("Audit producer request must be an object");
+                parseDelivery(body.delivery);
+                const submission = parseWireSubmission(body.submission);
+                const entry = await this.recorder().submit(submission);
+                this.store.saveReceipt(submission.producerEvent.eventId, entry, Date.now());
+                return json(entry);
+            }
+            if (request.method === "POST" && url.pathname === "/v1/outbox") {
+                const body = await request.json();
+                if (!isRecord(body) || parseDelivery(body.delivery) !== "buffered") {
+                    throw new TypeError("Audit outbox requires buffered delivery");
+                }
+                await this.delivery.enqueue(parseWireItem(body.item));
+                return json({ status: "pending" }, 202);
+            }
+            if (request.method === "GET" && url.pathname === "/v1/outbox/pending") {
+                const limit = boundedInteger(url.searchParams.get("limit") ?? undefined, 100, 1, 100);
+                const items = this.store.pending(Date.now(), limit, new Set());
+                return json({ items: items.map(toWireItem) });
+            }
+            if (request.method === "POST" && url.pathname === "/v1/outbox/flush") {
+                return json(await this.delivery.flush());
+            }
+            if (request.method === "POST" &&
+                url.pathname === "/v1/outbox/delivered") {
+                const body = await request.json();
+                if (!isRecord(body) || typeof body.eventId !== "string") {
+                    throw new TypeError("eventId is required");
+                }
+                if (!this.store.markDeliveredFromReceipt(body.eventId, Date.now())) {
+                    return problem(409, "AUDIT_RECEIPT_MISSING", "A verified receipt is required before delivery can complete");
+                }
+                await this.delivery.scheduleNext();
+                return json({ status: "delivered" });
+            }
+            if (request.method === "POST" && url.pathname === "/v1/outbox/failed") {
+                const body = await request.json();
+                if (!isRecord(body) || typeof body.eventId !== "string") {
+                    throw new TypeError("eventId is required");
+                }
+                const outcome = this.store.markFailed(body.eventId, typeof body.error === "string" ? body.error : "Audit delivery failed", Date.now(), this.policy);
+                await this.delivery.scheduleNext();
+                return json(outcome);
+            }
+            if (request.method === "GET" && url.pathname === "/v1/dead-letters") {
+                const limit = boundedInteger(url.searchParams.get("limit") ?? undefined, 25, 1, MAX_INSPECTION_LIMIT);
+                return json({ deadLetters: this.store.deadLetters(limit) });
+            }
+            const redrive = url.pathname.match(/^\/v1\/dead-letters\/([^/]+)\/redrive$/);
+            if (request.method === "POST" && redrive !== null) {
+                const eventId = decodeURIComponent(redrive[1]);
+                if (!this.store.redrive(eventId, Date.now())) {
+                    return problem(404, "AUDIT_DEAD_LETTER_NOT_FOUND", "Dead-lettered event was not found");
+                }
+                await this.delivery.scheduleNext();
+                return json({ status: "pending", eventId });
+            }
+            const receipt = url.pathname.match(/^\/v1\/receipts\/([^/]+)$/);
+            if (request.method === "GET" && receipt !== null) {
+                const eventId = decodeURIComponent(receipt[1]);
+                const entry = this.store.receipt(eventId);
+                return entry === undefined
+                    ? problem(404, "AUDIT_RECEIPT_NOT_FOUND", "Verified receipt was not found")
+                    : json(entry);
+            }
+            if (request.method === "POST" && url.pathname === "/v1/source/claim") {
+                const body = await request.json();
+                if (!isRecord(body) ||
+                    typeof body.sourceId !== "string" ||
+                    typeof body.eventId !== "string") {
+                    throw new TypeError("sourceId and eventId are required");
+                }
+                try {
+                    return json(this.store.claimEvent(body.sourceId, body.eventId));
+                }
+                catch (error) {
+                    if (error instanceof SourceConstructionPendingError) {
+                        return problem(409, "AUDIT_SOURCE_CONSTRUCTION_PENDING", error.message);
+                    }
+                    throw error;
+                }
+            }
+            if (request.method === "POST" && url.pathname === "/v1/source/emitted") {
+                const body = await request.json();
+                if (!isRecord(body) ||
+                    typeof body.sourceId !== "string" ||
+                    typeof body.eventId !== "string" ||
+                    typeof body.sequence !== "string" ||
+                    typeof body.eventDigest !== "string") {
+                    throw new TypeError("Source emission is malformed");
+                }
+                this.store.markEmitted(body.sourceId, body.eventId, body.sequence, body.eventDigest);
+                return json({ status: "emitted" });
+            }
+            if (request.method === "POST" &&
+                url.pathname === "/v1/source/receipted") {
+                const body = await request.json();
+                if (!isRecord(body) ||
+                    typeof body.sourceId !== "string" ||
+                    typeof body.sequence !== "string" ||
+                    typeof body.entryDigest !== "string") {
+                    throw new TypeError("Source receipt is malformed");
+                }
+                this.store.markReceipted(body.sourceId, body.sequence, body.entryDigest);
+                return json({ status: "receipted" });
+            }
+            if (request.method === "GET" && url.pathname === "/v1/source") {
+                const sourceId = url.searchParams.get("sourceId");
+                if (sourceId === null || sourceId.trim() === "") {
+                    throw new TypeError("sourceId is required");
+                }
+                return json(this.store.getSourceState(sourceId));
+            }
+            return problem(404, "AUDIT_PRODUCER_ROUTE_NOT_FOUND", "Audit producer route was not found");
+        }
+        catch (error) {
+            return problem(400, "AUDIT_PRODUCER_INVALID_REQUEST", errorMessage(error));
+        }
+    }
+    async alarm() {
+        await this.ready;
+        await this.delivery.flush();
+    }
+    recorder() {
+        this.recorderClient ??= buildVerifiedRecorder(this.env);
+        return this.recorderClient;
+    }
+}
+/** Client-side port used by AuditTrailService in the MCP worker. */
+export class CloudflareAuditProducerBinding {
+    options;
+    capabilities = {
+        durability: "durable",
+        fifoPerSource: true,
+        atomicClaim: true,
+    };
+    stub;
+    constructor(options) {
+        this.options = options;
+        if (options.instanceName.trim() === "") {
+            throw new TypeError("Audit producer instanceName must be non-empty");
+        }
+        const id = options.namespace.idFromName(options.instanceName);
+        this.stub = options.namespace.get(id);
+    }
+    async submit(input) {
+        const response = await this.request("/v1/record", {
+            method: "POST",
+            body: JSON.stringify({
+                delivery: this.options.delivery,
+                submission: toWireSubmission(input),
+            }),
+        });
+        return parseSignedAuditEntry(await response.json());
+    }
+    async enqueue(item) {
+        await this.request("/v1/outbox", {
+            method: "POST",
+            body: JSON.stringify({ delivery: "buffered", item: toWireItem(item) }),
+        });
+    }
+    async *pending(limit = 100) {
+        const response = await this.request(`/v1/outbox/pending?limit=${Math.max(1, Math.min(100, limit))}`);
+        const body = await response.json();
+        if (!isRecord(body) || !Array.isArray(body.items)) {
+            throw new Error("Audit producer returned a malformed pending response");
+        }
+        for (const item of body.items)
+            yield parseWireItem(item);
+    }
+    async markDelivered(eventId) {
+        await this.request("/v1/outbox/delivered", {
+            method: "POST",
+            body: JSON.stringify({ eventId }),
+        });
+    }
+    async markFailed(eventId, error) {
+        await this.request("/v1/outbox/failed", {
+            method: "POST",
+            body: JSON.stringify({ eventId, error: errorMessage(error) }),
+        });
+    }
+    async claimEvent(sourceId, eventId) {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                const response = await this.request("/v1/source/claim", {
+                    method: "POST",
+                    body: JSON.stringify({ sourceId, eventId }),
+                });
+                return (await response.json());
+            }
+            catch (error) {
+                if (!(error instanceof AuditProducerRequestError) ||
+                    error.status !== 409 ||
+                    attempt >= 9) {
+                    throw error;
+                }
+                await new Promise((resolve) => setTimeout(resolve, Math.min(50, 5 * 2 ** attempt)));
+            }
+        }
+    }
+    async markEmitted(sourceId, eventId, sequence, eventDigest) {
+        await this.request("/v1/source/emitted", {
+            method: "POST",
+            body: JSON.stringify({ sourceId, eventId, sequence, eventDigest }),
+        });
+    }
+    async markReceipted(sourceId, sequence, entryDigest) {
+        await this.request("/v1/source/receipted", {
+            method: "POST",
+            body: JSON.stringify({ sourceId, sequence, entryDigest }),
+        });
+    }
+    async getState(sourceId) {
+        const response = await this.request(`/v1/source?sourceId=${encodeURIComponent(sourceId)}`);
+        return (await response.json());
+    }
+    /** Return only a locally verified recorder entry retained by the producer. */
+    async receipt(eventId) {
+        try {
+            const response = await this.request(`/v1/receipts/${encodeURIComponent(eventId)}`);
+            return parseSignedAuditEntry(await response.json());
+        }
+        catch (error) {
+            if (error instanceof AuditProducerRequestError && error.status === 404)
+                return undefined;
+            throw error;
+        }
+    }
+    async request(path, init = {}) {
+        const requestHeaders = new Headers(init.headers);
+        if (init.body !== undefined)
+            requestHeaders.set("Content-Type", "application/json");
+        if (this.options.internalToken !== undefined) {
+            requestHeaders.set(INTERNAL_TOKEN_HEADER, this.options.internalToken);
+        }
+        const response = await this.stub.fetch(`${INTERNAL_ORIGIN}${path}`, {
+            ...init,
+            headers: requestHeaders,
+        });
+        if (!response.ok) {
+            let detail = `HTTP ${response.status}`;
+            try {
+                const body = await response.json();
+                if (isRecord(body) && typeof body.detail === "string")
+                    detail = body.detail;
+            }
+            catch {
+                // Preserve the status-only detail for malformed error responses.
+            }
+            throw new AuditProducerRequestError(response.status, detail);
+        }
+        return response;
+    }
+}
+/** Compose the core audit trail with durable Cloudflare producer mechanics. */
+export function createCloudflareAuditTrail(options) {
+    if (options.env.AUDIT_PRODUCER === undefined) {
+        throw new Error("AUDIT_PRODUCER Durable Object binding is required for Cloudflare audit");
+    }
+    const internalToken = options.env.KYA_OS_AUDIT_PRODUCER_INTERNAL_TOKEN;
+    if (typeof internalToken !== "string" || internalToken.trim().length === 0) {
+        throw new Error("KYA_OS_AUDIT_PRODUCER_INTERNAL_TOKEN is required for Cloudflare audit");
+    }
+    const producer = new CloudflareAuditProducerBinding({
+        namespace: options.env.AUDIT_PRODUCER,
+        instanceName: options.instanceName ?? `${options.ledgerId}\0${options.sourceId}`,
+        delivery: options.delivery,
+        internalToken,
+    });
+    return createAuditTrail({
+        recorder: producer,
+        delivery: options.delivery,
+        hasher: options.hasher ?? new CryptoProviderAuditHasher(new WebCryptoProvider()),
+        ledgerId: options.ledgerId,
+        ...(options.expectedLedgerEpochId === undefined
+            ? {}
+            : { expectedLedgerEpochId: options.expectedLedgerEpochId }),
+        tenantRef: options.tenantRef,
+        producer: options.producer,
+        sourceId: options.sourceId,
+        binding: options.binding,
+        privacy: options.privacy,
+        clock: options.clock ?? { now: () => Date.now() },
+        sourceState: producer,
+        ...(options.delivery === "buffered" ? { outbox: producer } : {}),
+        ...(options.eventIdFactory === undefined
+            ? {}
+            : { eventIdFactory: options.eventIdFactory }),
+        ...(options.onDeliveryFailure === undefined
+            ? {}
+            : { onDeliveryFailure: options.onDeliveryFailure }),
+        ...(options.onSourceStateFailure === undefined
+            ? {}
+            : { onSourceStateFailure: options.onSourceStateFailure }),
+        ...(options.capabilities === undefined
+            ? {}
+            : { capabilities: options.capabilities }),
+    });
+}
+//# sourceMappingURL=durable-producer.js.map