@xenosystem/agent-interface-host 0.1.7 → 0.1.9

package/dist/state/ProviderLaneSqliteStore.js

@@ -0,0 +1,728 @@
+import { createHash } from 'node:crypto';
+import { toProviderLaneProjection, } from './providerLaneTypes.js';
+const MAX_ID = 240;
+const MAX_LABEL = 1024;
+const MAX_REASON = 2048;
+const MAX_CAPABILITIES_JSON = 256 * 1024;
+const MAX_CONTINUATION_JSON = 4 * 1024 * 1024;
+const MAX_CIPHERTEXT = 8 * 1024 * 1024;
+const MAX_EVENT_JSON = 1024 * 1024;
+const MAX_RECEIPT_JSON = 1024 * 1024;
+const MAX_DIRECTORY_FINGERPRINTS = 1024;
+export class ProviderLaneStoreError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'ProviderLaneStoreError';
+        this.code = code;
+    }
+}
+export class ProviderLaneSqliteStore {
+    database;
+    cipher;
+    constructor(database, cipher) {
+        this.database = database;
+        this.cipher = cipher;
+    }
+    listLaneProjections(conversationId, includeHistorical = true) {
+        const boundedConversationId = requiredString(conversationId, 'conversationId', MAX_ID);
+        const rows = this.database.prepare(`
+      SELECT * FROM provider_lanes
+      WHERE conversation_id = ? ${includeHistorical ? '' : 'AND is_active = 1'}
+      ORDER BY is_active DESC, updated_at DESC, lane_id ASC
+    `).all(boundedConversationId);
+        return rows.map((row) => toProviderLaneProjection(rowToLane(requireRecord(row), undefined, false)));
+    }
+    getLaneProjection(conversationId, laneId) {
+        const row = this.database.prepare('SELECT * FROM provider_lanes WHERE conversation_id = ? AND lane_id = ?').get(requiredString(conversationId, 'conversationId', MAX_ID), requiredString(laneId, 'laneId', MAX_ID));
+        return row ? toProviderLaneProjection(rowToLane(requireRecord(row), undefined, false)) : null;
+    }
+    getLane(laneId, includeContinuation = false) {
+        const row = this.database.prepare('SELECT * FROM provider_lanes WHERE lane_id = ?')
+            .get(requiredString(laneId, 'laneId', MAX_ID));
+        return row ? rowToLane(requireRecord(row), this.cipher, includeContinuation) : null;
+    }
+    getActiveLane(conversationId, includeContinuation = false) {
+        const row = this.database.prepare('SELECT * FROM provider_lanes WHERE conversation_id = ? AND is_active = 1').get(requiredString(conversationId, 'conversationId', MAX_ID));
+        return row ? rowToLane(requireRecord(row), this.cipher, includeContinuation) : null;
+    }
+    replayIdempotency(idempotencyKey, requestHash) {
+        const key = requiredString(idempotencyKey, 'idempotencyKey', MAX_ID);
+        requiredHash(requestHash, 'requestHash');
+        const receipt = this.readReceipt(key);
+        if (!receipt)
+            return { found: false };
+        if (receipt.requestHash !== requestHash)
+            return { found: true, conflict: true };
+        return { found: true, conflict: false, response: structuredClone(receipt.response) };
+    }
+    saveLane(lane, expectedRevision, makeActive = lane.isActive) {
+        try {
+            return inTransaction(this.database, () => this.saveLaneInTransaction(lane, expectedRevision, makeActive));
+        }
+        catch (error) {
+            return failure(error);
+        }
+    }
+    selectLane(conversationId, laneId, expectedRevision) {
+        try {
+            const boundedConversationId = requiredString(conversationId, 'conversationId', MAX_ID);
+            const boundedLaneId = requiredString(laneId, 'laneId', MAX_ID);
+            const revision = requiredRevision(expectedRevision, 'expectedRevision');
+            return inTransaction(this.database, () => {
+                const now = new Date().toISOString();
+                this.database.prepare(`
+          UPDATE provider_lanes
+          SET is_active = 0, revision = revision + 1, updated_at = ?
+          WHERE conversation_id = ? AND is_active = 1 AND lane_id <> ?
+        `).run(now, boundedConversationId, boundedLaneId);
+                const result = this.database.prepare(`
+          UPDATE provider_lanes
+          SET is_active = 1, revision = revision + 1, updated_at = ?
+          WHERE lane_id = ? AND conversation_id = ? AND revision = ?
+        `).run(now, boundedLaneId, boundedConversationId, revision);
+                if (changes(result) !== 1) {
+                    throw new ProviderLaneStoreError('LANE_REVISION_CONFLICT', 'Provider lane revision changed before selection.');
+                }
+                const lane = this.requireLaneInTransaction(boundedLaneId, false);
+                return { success: true, lane, projection: toProviderLaneProjection(lane) };
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    }
+    commitLaneTransition(input) {
+        try {
+            validateTransitionInput(input);
+            return inTransaction(this.database, () => {
+                if (input.idempotency) {
+                    const replay = this.readReceipt(input.idempotency.idempotencyKey);
+                    if (replay) {
+                        if (replay.requestHash !== input.idempotency.requestHash) {
+                            throw new ProviderLaneStoreError('LANE_REVISION_CONFLICT', 'Idempotency key was already used for a different request.');
+                        }
+                        return {
+                            success: true,
+                            replayed: true,
+                            response: replay.response,
+                            outboxIds: [],
+                        };
+                    }
+                }
+                let laneResult;
+                if (input.lane) {
+                    if (input.expectedRevision === undefined) {
+                        throw new ProviderLaneStoreError('LANE_REVISION_CONFLICT', 'expectedRevision is required for lane mutation.');
+                    }
+                    laneResult = this.saveLaneInTransaction(input.lane, input.expectedRevision, input.lane.isActive);
+                }
+                const outboxIds = [];
+                const outbox = input.outbox ? (Array.isArray(input.outbox) ? input.outbox : [input.outbox]) : [];
+                for (const entry of outbox) {
+                    validateOutboxDraft(entry);
+                    const payloadJson = boundedJson(entry.payload, 'outbox payload', MAX_EVENT_JSON);
+                    const payloadHash = sha256(payloadJson);
+                    const now = new Date().toISOString();
+                    this.database.prepare(`
+            INSERT INTO provider_transition_outbox(
+              outbox_id, schema_version, conversation_id, lane_id, lane_revision,
+              transition_type, event_id, idempotency_key, payload_json, payload_hash,
+              status, retry_count, created_at, updated_at
+            ) VALUES (?, 1, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', 0, ?, ?)
+          `).run(entry.outboxId, entry.conversationId, entry.laneId, entry.laneRevision, entry.transitionType, entry.eventId, entry.idempotencyKey, payloadJson, payloadHash, now, now);
+                    outboxIds.push(entry.outboxId);
+                }
+                if (input.lease)
+                    this.insertLeaseInTransaction(input.lease);
+                let response;
+                if (input.idempotency) {
+                    response = validateReceiptDraft(input.idempotency);
+                    const responseJson = boundedJson(response, 'idempotency response', MAX_RECEIPT_JSON);
+                    this.database.prepare(`
+            INSERT INTO idempotency_receipts(
+              idempotency_key, scope, request_id, request_hash, lane_id, conversation_id,
+              response_json, response_hash, created_at, expires_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `).run(input.idempotency.idempotencyKey, input.idempotency.scope, input.idempotency.requestId, input.idempotency.requestHash, input.idempotency.laneId ?? input.lane?.laneId ?? null, input.idempotency.conversationId ?? input.lane?.conversationId ?? null, responseJson, sha256(responseJson), new Date().toISOString(), input.idempotency.expiresAt ?? null);
+                }
+                return {
+                    success: true,
+                    replayed: false,
+                    ...(laneResult?.lane ? { lane: laneResult.lane, projection: laneResult.projection } : {}),
+                    ...(response ? { response } : {}),
+                    outboxIds,
+                };
+            });
+        }
+        catch (error) {
+            return { ...failure(error), outboxIds: [] };
+        }
+    }
+    listPendingOutbox(limit = 100) {
+        const boundedLimit = Number.isInteger(limit) && limit > 0 && limit <= 1000 ? limit : 100;
+        return this.database.prepare(`
+      SELECT * FROM provider_transition_outbox
+      WHERE status IN ('pending', 'failed')
+      ORDER BY created_at ASC, outbox_id ASC
+      LIMIT ?
+    `).all(boundedLimit).map((row) => rowToOutbox(requireRecord(row)));
+    }
+    markOutboxDelivered(outboxId, payloadHash) {
+        const id = requiredString(outboxId, 'outboxId', MAX_ID);
+        const hash = requiredHash(payloadHash, 'payloadHash');
+        return inTransaction(this.database, () => {
+            const now = new Date().toISOString();
+            const result = this.database.prepare(`
+        UPDATE provider_transition_outbox
+        SET status = 'delivered', delivered_at = ?, updated_at = ?, error = NULL
+        WHERE outbox_id = ? AND payload_hash = ? AND status IN ('pending', 'failed')
+      `).run(now, now, id, hash);
+            if (changes(result) === 1)
+                return true;
+            const existing = requireRecordOrNull(this.database.prepare('SELECT payload_hash, status FROM provider_transition_outbox WHERE outbox_id = ?').get(id));
+            if (!existing)
+                return false;
+            if (existing.payload_hash !== hash) {
+                throw new ProviderLaneStoreError('CONTINUATION_INVALID', 'Outbox payload hash conflict.');
+            }
+            return existing.status === 'delivered';
+        });
+    }
+    markOutboxFailed(outboxId, error) {
+        const result = this.database.prepare(`
+      UPDATE provider_transition_outbox
+      SET status = 'failed', retry_count = retry_count + 1, last_attempt_at = ?, error = ?, updated_at = ?
+      WHERE outbox_id = ? AND status <> 'delivered'
+    `).run(new Date().toISOString(), optionalString(error, 'outbox error', MAX_REASON) ?? 'Projection failed.', new Date().toISOString(), requiredString(outboxId, 'outboxId', MAX_ID));
+        return changes(result) === 1;
+    }
+    getActiveLease(laneId) {
+        const row = this.database.prepare(`
+      SELECT * FROM provider_writer_leases
+      WHERE lane_id = ? AND state IN ('active', 'releasing', 'unknown')
+    `).get(requiredString(laneId, 'laneId', MAX_ID));
+        return row ? rowToLease(requireRecord(row)) : null;
+    }
+    getLease(leaseId) {
+        const row = this.database.prepare('SELECT * FROM provider_writer_leases WHERE lease_id = ?')
+            .get(requiredString(leaseId, 'leaseId', MAX_ID));
+        return row ? rowToLease(requireRecord(row)) : null;
+    }
+    replaceExpiredLeaseAtomic(existingLeaseId, expectedLeaseRevision, replacement) {
+        try {
+            validateLease(replacement);
+            const existingId = requiredString(existingLeaseId, 'existingLeaseId', MAX_ID);
+            const expected = positiveInteger(expectedLeaseRevision, 'expectedLeaseRevision');
+            return inTransaction(this.database, () => {
+                const now = new Date().toISOString();
+                const released = this.database.prepare(`
+          UPDATE provider_writer_leases
+          SET state = 'stale', lease_revision = lease_revision + 1, updated_at = ?
+          WHERE lease_id = ? AND lease_revision = ? AND state IN ('active', 'releasing', 'unknown')
+        `).run(now, existingId, expected);
+                if (changes(released) !== 1) {
+                    throw new ProviderLaneStoreError('LANE_WRITER_UNKNOWN', 'Writer lease changed during liveness recovery.');
+                }
+                this.insertLeaseInTransaction({ ...replacement, leaseRevision: 1 });
+                const stored = this.getLease(replacement.leaseId);
+                return { success: true, ...(stored ? { lease: stored } : {}) };
+            });
+        }
+        catch (error) {
+            if (isUniqueConstraint(error)) {
+                return { success: false, code: 'LANE_WRITER_ACTIVE', error: 'Provider lane already has a conflicting writer.' };
+            }
+            const failed = failure(error);
+            return { success: false, ...(failed.code ? { code: failed.code } : {}), ...(failed.error ? { error: failed.error } : {}) };
+        }
+    }
+    saveLeaseAtomic(lease, expectedLeaseRevision) {
+        try {
+            validateLease(lease);
+            const expected = requiredRevision(expectedLeaseRevision, 'expectedLeaseRevision');
+            return inTransaction(this.database, () => {
+                if (expected === 0) {
+                    this.insertLeaseInTransaction({ ...lease, leaseRevision: 1 });
+                }
+                else {
+                    const result = this.database.prepare(`
+            UPDATE provider_writer_leases SET
+              lane_revision = ?, native_provider_id = ?, native_session_hash = ?, owner_surface = ?,
+              owner_pid = ?, owner_process_start_time = ?, owner_process_identity = ?, state = ?,
+              expires_at = ?, renewed_at = ?, last_heartbeat_at = ?, workspace_epoch_id = ?,
+              authority_snapshot_hash = ?, lease_revision = lease_revision + 1, updated_at = ?
+            WHERE lease_id = ? AND lease_revision = ?
+          `).run(lease.laneRevision, lease.nativeProviderId ?? null, lease.nativeSessionHash ?? null, lease.ownerSurface, lease.ownerPid, lease.ownerProcessStartTime, lease.ownerProcessIdentity, lease.state, lease.expiresAt, lease.renewedAt ?? null, lease.lastHeartbeatAt, lease.workspaceEpochId, lease.authoritySnapshotHash, new Date().toISOString(), lease.leaseId, expected);
+                    if (changes(result) !== 1) {
+                        throw new ProviderLaneStoreError('LANE_REVISION_CONFLICT', 'Writer lease revision changed before mutation.');
+                    }
+                }
+                const stored = this.database.prepare('SELECT * FROM provider_writer_leases WHERE lease_id = ?')
+                    .get(lease.leaseId);
+                if (!stored)
+                    throw new Error('Writer lease was not stored.');
+                return { success: true, lease: rowToLease(requireRecord(stored)) };
+            });
+        }
+        catch (error) {
+            if (isUniqueConstraint(error)) {
+                return { success: false, code: 'LANE_WRITER_ACTIVE', error: 'Provider lane already has a conflicting writer.' };
+            }
+            const failed = failure(error);
+            return { success: false, ...(failed.code ? { code: failed.code } : {}), ...(failed.error ? { error: failed.error } : {}) };
+        }
+    }
+    saveLaneInTransaction(lane, expectedRevision, makeActive) {
+        validateLane(lane);
+        const expected = requiredRevision(expectedRevision, 'expectedRevision');
+        const encoded = encodeLane(lane, this.cipher);
+        const now = new Date().toISOString();
+        if (makeActive) {
+            this.database.prepare(`
+        UPDATE provider_lanes
+        SET is_active = 0, revision = revision + 1, updated_at = ?
+        WHERE conversation_id = ? AND is_active = 1 AND lane_id <> ?
+      `).run(now, lane.conversationId, lane.laneId);
+        }
+        if (expected === 0) {
+            const existing = this.database.prepare('SELECT lane_id FROM provider_lanes WHERE lane_id = ?').get(lane.laneId);
+            if (existing)
+                throw new ProviderLaneStoreError('LANE_REVISION_CONFLICT', 'Provider lane already exists.');
+            this.database.prepare(`
+        INSERT INTO provider_lanes(
+          lane_id, conversation_id, runtime_provider_id, provider_kind, provider_display_name,
+          native_provider_id, model_id, model_display_name, resume_compatibility_key,
+          workspace_epoch_id, workspace_epoch_fingerprint, workspace_epoch_wire_mode, workspace_epoch_kind,
+          workspace_epoch_label, workspace_epoch_allowed_directory_fingerprints_json, status,
+          encrypted_continuation, continuation_hash, revision, is_active, capabilities_json,
+          last_request_id, last_used_at, last_structured_commit_id, last_handoff_capsule_id,
+          redacted_native_session_hash, invalidation_reason, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(...encoded.insertValues, makeActive ? 1 : 0, encoded.capabilitiesJson, ...encoded.tailValues, now);
+        }
+        else {
+            const result = this.database.prepare(`
+        UPDATE provider_lanes SET
+          runtime_provider_id = ?, provider_kind = ?, provider_display_name = ?, native_provider_id = ?,
+          model_id = ?, model_display_name = ?, resume_compatibility_key = ?, workspace_epoch_id = ?,
+          workspace_epoch_fingerprint = ?, workspace_epoch_wire_mode = ?, workspace_epoch_kind = ?,
+          workspace_epoch_label = ?, workspace_epoch_allowed_directory_fingerprints_json = ?, status = ?,
+          encrypted_continuation = ?, continuation_hash = ?, is_active = ?, capabilities_json = ?,
+          last_request_id = ?, last_used_at = ?, last_structured_commit_id = ?, last_handoff_capsule_id = ?,
+          redacted_native_session_hash = ?, invalidation_reason = ?, revision = revision + 1, updated_at = ?
+        WHERE lane_id = ? AND conversation_id = ? AND revision = ?
+      `).run(...encoded.updateValues, makeActive ? 1 : 0, encoded.capabilitiesJson, ...encoded.updateTailValues, now, lane.laneId, lane.conversationId, expected);
+            if (changes(result) !== 1) {
+                throw new ProviderLaneStoreError('LANE_REVISION_CONFLICT', 'Provider lane revision changed before mutation.');
+            }
+        }
+        const stored = this.requireLaneInTransaction(lane.laneId, false);
+        return { success: true, lane: stored, projection: toProviderLaneProjection(stored) };
+    }
+    requireLaneInTransaction(laneId, includeContinuation) {
+        const row = this.database.prepare('SELECT * FROM provider_lanes WHERE lane_id = ?').get(laneId);
+        if (!row)
+            throw new ProviderLaneStoreError('CONVERSATION_NOT_FOUND', 'Provider lane was not found.');
+        return rowToLane(requireRecord(row), this.cipher, includeContinuation);
+    }
+    insertLeaseInTransaction(lease) {
+        validateLease(lease);
+        this.database.prepare(`
+      INSERT INTO provider_writer_leases(
+        lease_id, schema_version, lane_id, lane_revision, lease_revision, conversation_id,
+        host_instance_id, runtime_provider_id, native_provider_id, native_session_hash,
+        owner_surface, owner_pid, owner_process_start_time, owner_process_identity, state,
+        acquired_at, expires_at, renewed_at, last_heartbeat_at, workspace_epoch_id,
+        authority_snapshot_hash, created_at, updated_at
+      ) VALUES (?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(lease.leaseId, lease.laneId, lease.laneRevision, lease.leaseRevision, lease.conversationId, lease.hostInstanceId, lease.runtimeProviderId, lease.nativeProviderId ?? null, lease.nativeSessionHash ?? null, lease.ownerSurface, lease.ownerPid, lease.ownerProcessStartTime, lease.ownerProcessIdentity, lease.state, lease.acquiredAt, lease.expiresAt, lease.renewedAt ?? null, lease.lastHeartbeatAt, lease.workspaceEpochId, lease.authoritySnapshotHash, lease.createdAt, lease.updatedAt);
+    }
+    readReceipt(idempotencyKey) {
+        const row = this.database.prepare('SELECT request_hash, response_json, response_hash FROM idempotency_receipts WHERE idempotency_key = ?').get(requiredString(idempotencyKey, 'idempotencyKey', MAX_ID));
+        if (!row)
+            return null;
+        const record = requireRecord(row);
+        const responseJson = requiredString(record.response_json, 'stored response', MAX_RECEIPT_JSON);
+        if (sha256(responseJson) !== record.response_hash) {
+            throw new ProviderLaneStoreError('CONTINUATION_INVALID', 'Stored idempotency receipt is invalid.');
+        }
+        try {
+            const response = JSON.parse(responseJson);
+            if (!isRecord(response))
+                throw new Error('response is not an object');
+            return {
+                requestHash: requiredHash(record.request_hash, 'stored requestHash'),
+                response,
+            };
+        }
+        catch {
+            throw new ProviderLaneStoreError('CONTINUATION_INVALID', 'Stored idempotency receipt is invalid.');
+        }
+    }
+}
+function encodeLane(lane, cipher) {
+    const continuation = encryptContinuation(lane.continuation, cipher);
+    const capabilitiesJson = lane.capabilities
+        ? boundedJson(lane.capabilities, 'provider capabilities', MAX_CAPABILITIES_JSON)
+        : null;
+    const directoryFingerprints = boundedJson(lane.workspaceEpoch.allowedDirectoryFingerprints, 'allowed directory fingerprints', 64 * 1024);
+    const insertValues = [
+        lane.laneId,
+        lane.conversationId,
+        lane.runtimeProviderId,
+        lane.providerKind,
+        lane.providerDisplayName ?? null,
+        lane.nativeProviderId ?? null,
+        lane.modelId ?? null,
+        lane.modelDisplayName ?? null,
+        lane.resumeCompatibilityKey,
+        lane.workspaceEpoch.id,
+        lane.workspaceEpoch.fingerprint,
+        lane.workspaceEpoch.wireMode,
+        lane.workspaceEpoch.kind,
+        lane.workspaceEpoch.label ?? null,
+        directoryFingerprints,
+        lane.status,
+        continuation.ciphertext,
+        continuation.hash,
+    ];
+    const updateValues = insertValues.slice(2);
+    const tailValues = [
+        lane.lastRequestId ?? null,
+        lane.lastUsedAt ?? null,
+        lane.lastStructuredCommitId ?? null,
+        lane.lastHandoffCapsuleId ?? null,
+        lane.redactedNativeSessionHash ?? null,
+        lane.invalidationReason ?? null,
+        lane.createdAt,
+    ];
+    return {
+        insertValues,
+        updateValues,
+        capabilitiesJson,
+        tailValues,
+        updateTailValues: tailValues.slice(0, -1),
+    };
+}
+function encryptContinuation(value, cipher) {
+    if (value === undefined)
+        return { ciphertext: null, hash: null };
+    if (!cipher?.available) {
+        throw new ProviderLaneStoreError('SECURE_LANE_STORE_UNAVAILABLE', 'Secure provider lane storage is unavailable.');
+    }
+    const plaintext = boundedJson(value, 'provider continuation', MAX_CONTINUATION_JSON);
+    let ciphertext;
+    try {
+        ciphertext = cipher.encrypt(plaintext);
+    }
+    catch {
+        throw new ProviderLaneStoreError('SECURE_LANE_STORE_UNAVAILABLE', 'Secure provider lane storage is unavailable.');
+    }
+    requiredString(ciphertext, 'encrypted continuation', MAX_CIPHERTEXT);
+    return { ciphertext, hash: sha256(ciphertext) };
+}
+function decryptContinuation(ciphertext, cipher) {
+    if (ciphertext === null || ciphertext === undefined)
+        return undefined;
+    if (!cipher?.available) {
+        throw new ProviderLaneStoreError('SECURE_LANE_STORE_UNAVAILABLE', 'Secure provider lane storage is unavailable.');
+    }
+    try {
+        const encrypted = requiredString(ciphertext, 'encrypted continuation', MAX_CIPHERTEXT);
+        const plaintext = cipher.decrypt(encrypted);
+        requiredString(plaintext, 'provider continuation', MAX_CONTINUATION_JSON);
+        return JSON.parse(plaintext);
+    }
+    catch {
+        throw new ProviderLaneStoreError('CONTINUATION_INVALID', 'Protected provider continuation is invalid.');
+    }
+}
+function rowToLane(row, cipher, includeContinuation) {
+    const allowed = parseStringArray(row.workspace_epoch_allowed_directory_fingerprints_json);
+    const capabilities = parseOptionalRecord(row.capabilities_json);
+    const lane = {
+        schemaVersion: 1,
+        laneId: requiredString(row.lane_id, 'stored laneId', MAX_ID),
+        conversationId: requiredString(row.conversation_id, 'stored conversationId', MAX_ID),
+        runtimeProviderId: requiredString(row.runtime_provider_id, 'stored runtimeProviderId', MAX_ID),
+        providerKind: requiredString(row.provider_kind, 'stored providerKind', 120),
+        ...(optionalString(row.provider_display_name, 'stored providerDisplayName', 512) ? { providerDisplayName: String(row.provider_display_name) } : {}),
+        ...(optionalString(row.native_provider_id, 'stored nativeProviderId', MAX_ID) ? { nativeProviderId: String(row.native_provider_id) } : {}),
+        ...(optionalString(row.model_id, 'stored modelId', MAX_ID) ? { modelId: String(row.model_id) } : {}),
+        ...(optionalString(row.model_display_name, 'stored modelDisplayName', 512) ? { modelDisplayName: String(row.model_display_name) } : {}),
+        resumeCompatibilityKey: requiredString(row.resume_compatibility_key, 'stored resumeCompatibilityKey', 512),
+        workspaceEpoch: {
+            id: requiredString(row.workspace_epoch_id, 'stored workspaceEpochId', MAX_ID),
+            fingerprint: requiredString(row.workspace_epoch_fingerprint, 'stored workspaceEpochFingerprint', 512),
+            wireMode: requireOneOf(row.workspace_epoch_wire_mode, ['chat', 'development'], 'stored workspace wire mode'),
+            kind: requireOneOf(row.workspace_epoch_kind, ['private-chat', 'local-workspace'], 'stored workspace kind'),
+            ...(optionalString(row.workspace_epoch_label, 'stored workspaceEpochLabel', MAX_LABEL) ? { label: String(row.workspace_epoch_label) } : {}),
+            allowedDirectoryFingerprints: allowed,
+        },
+        status: requireOneOf(row.status, [
+            'new', 'clean', 'active_structured', 'active_native', 'externally_advanced',
+            'needs_reconciliation', 'portable_only', 'invalidated', 'error',
+        ], 'stored lane status'),
+        revision: requiredRevision(row.revision, 'stored revision'),
+        isActive: row.is_active === 1,
+        ...(capabilities ? { capabilities } : {}),
+        ...(optionalString(row.continuation_hash, 'stored continuationHash', 128) ? { continuationHash: String(row.continuation_hash) } : {}),
+        ...(optionalString(row.last_request_id, 'stored lastRequestId', MAX_ID) ? { lastRequestId: String(row.last_request_id) } : {}),
+        ...(optionalString(row.last_used_at, 'stored lastUsedAt', 64) ? { lastUsedAt: String(row.last_used_at) } : {}),
+        ...(optionalString(row.last_structured_commit_id, 'stored lastStructuredCommitId', MAX_ID) ? { lastStructuredCommitId: String(row.last_structured_commit_id) } : {}),
+        ...(optionalString(row.last_handoff_capsule_id, 'stored lastHandoffCapsuleId', MAX_ID) ? { lastHandoffCapsuleId: String(row.last_handoff_capsule_id) } : {}),
+        ...(optionalString(row.redacted_native_session_hash, 'stored redactedNativeSessionHash', 128) ? { redactedNativeSessionHash: String(row.redacted_native_session_hash) } : {}),
+        ...(optionalString(row.invalidation_reason, 'stored invalidationReason', MAX_REASON) ? { invalidationReason: String(row.invalidation_reason) } : {}),
+        createdAt: requiredString(row.created_at, 'stored createdAt', 64),
+        updatedAt: requiredString(row.updated_at, 'stored updatedAt', 64),
+    };
+    if (includeContinuation)
+        lane.continuation = decryptContinuation(row.encrypted_continuation, cipher);
+    return lane;
+}
+function rowToLease(row) {
+    return {
+        schemaVersion: 1,
+        leaseId: requiredString(row.lease_id, 'stored leaseId', MAX_ID),
+        laneId: requiredString(row.lane_id, 'stored laneId', MAX_ID),
+        laneRevision: requiredRevision(row.lane_revision, 'stored laneRevision'),
+        leaseRevision: positiveInteger(row.lease_revision, 'stored leaseRevision'),
+        conversationId: requiredString(row.conversation_id, 'stored conversationId', MAX_ID),
+        hostInstanceId: requiredString(row.host_instance_id, 'stored hostInstanceId', MAX_ID),
+        runtimeProviderId: requiredString(row.runtime_provider_id, 'stored runtimeProviderId', MAX_ID),
+        ...(optionalString(row.native_provider_id, 'stored nativeProviderId', MAX_ID) ? { nativeProviderId: String(row.native_provider_id) } : {}),
+        ...(optionalString(row.native_session_hash, 'stored nativeSessionHash', 128) ? { nativeSessionHash: String(row.native_session_hash) } : {}),
+        ownerSurface: requiredString(row.owner_surface, 'stored ownerSurface', 120),
+        ownerPid: positiveInteger(row.owner_pid, 'stored ownerPid'),
+        ownerProcessStartTime: requiredString(row.owner_process_start_time, 'stored process start time', 128),
+        ownerProcessIdentity: requiredString(row.owner_process_identity, 'stored process identity', 512),
+        state: requireOneOf(row.state, ['active', 'releasing', 'released', 'stale', 'unknown'], 'stored lease state'),
+        acquiredAt: requiredString(row.acquired_at, 'stored acquiredAt', 64),
+        expiresAt: requiredString(row.expires_at, 'stored expiresAt', 64),
+        ...(optionalString(row.renewed_at, 'stored renewedAt', 64) ? { renewedAt: String(row.renewed_at) } : {}),
+        lastHeartbeatAt: requiredString(row.last_heartbeat_at, 'stored lastHeartbeatAt', 64),
+        workspaceEpochId: requiredString(row.workspace_epoch_id, 'stored workspaceEpochId', MAX_ID),
+        authoritySnapshotHash: requiredString(row.authority_snapshot_hash, 'stored authoritySnapshotHash', 512),
+        createdAt: requiredString(row.created_at, 'stored createdAt', 64),
+        updatedAt: requiredString(row.updated_at, 'stored updatedAt', 64),
+    };
+}
+function rowToOutbox(row) {
+    let payload;
+    try {
+        const parsed = JSON.parse(requiredString(row.payload_json, 'stored outbox payload', MAX_EVENT_JSON));
+        if (!isRecord(parsed))
+            throw new Error('payload is not an object');
+        payload = parsed;
+    }
+    catch {
+        throw new ProviderLaneStoreError('CONTINUATION_INVALID', 'Stored outbox payload is invalid.');
+    }
+    return {
+        schemaVersion: 1,
+        outboxId: requiredString(row.outbox_id, 'stored outboxId', MAX_ID),
+        conversationId: requiredString(row.conversation_id, 'stored conversationId', MAX_ID),
+        laneId: requiredString(row.lane_id, 'stored laneId', MAX_ID),
+        laneRevision: requiredRevision(row.lane_revision, 'stored laneRevision'),
+        transitionType: requiredString(row.transition_type, 'stored transitionType', 120),
+        eventId: requiredString(row.event_id, 'stored eventId', MAX_ID),
+        idempotencyKey: requiredString(row.idempotency_key, 'stored idempotencyKey', MAX_ID),
+        payload,
+        payloadHash: requiredHash(row.payload_hash, 'stored payloadHash'),
+        status: requireOneOf(row.status, ['pending', 'delivered', 'failed', 'abandoned'], 'stored outbox status'),
+        retryCount: requiredRevision(row.retry_count, 'stored retryCount'),
+        ...(optionalString(row.last_attempt_at, 'stored lastAttemptAt', 64) ? { lastAttemptAt: String(row.last_attempt_at) } : {}),
+        ...(optionalString(row.error, 'stored outbox error', MAX_REASON) ? { error: String(row.error) } : {}),
+        createdAt: requiredString(row.created_at, 'stored createdAt', 64),
+        ...(optionalString(row.delivered_at, 'stored deliveredAt', 64) ? { deliveredAt: String(row.delivered_at) } : {}),
+        updatedAt: requiredString(row.updated_at, 'stored updatedAt', 64),
+    };
+}
+function validateLane(lane) {
+    if (!isRecord(lane) || lane.schemaVersion !== 1)
+        throw new Error('Invalid provider lane.');
+    requiredString(lane.laneId, 'laneId', MAX_ID);
+    requiredString(lane.conversationId, 'conversationId', MAX_ID);
+    requiredString(lane.runtimeProviderId, 'runtimeProviderId', MAX_ID);
+    requiredString(lane.providerKind, 'providerKind', 120);
+    requiredString(lane.resumeCompatibilityKey, 'resumeCompatibilityKey', 512);
+    requiredString(lane.workspaceEpoch.id, 'workspaceEpoch.id', MAX_ID);
+    requiredString(lane.workspaceEpoch.fingerprint, 'workspaceEpoch.fingerprint', 512);
+    if (lane.workspaceEpoch.allowedDirectoryFingerprints.length > MAX_DIRECTORY_FINGERPRINTS) {
+        throw new Error('Too many allowed directory fingerprints.');
+    }
+    for (const fingerprint of lane.workspaceEpoch.allowedDirectoryFingerprints) {
+        requiredString(fingerprint, 'allowed directory fingerprint', 512);
+    }
+    requiredRevision(lane.revision, 'lane revision');
+    requiredString(lane.createdAt, 'createdAt', 64);
+    requiredString(lane.updatedAt, 'updatedAt', 64);
+    optionalString(lane.invalidationReason, 'invalidationReason', MAX_REASON);
+}
+function validateLease(lease) {
+    if (!isRecord(lease) || lease.schemaVersion !== 1)
+        throw new Error('Invalid provider writer lease.');
+    for (const [field, value, max] of [
+        ['leaseId', lease.leaseId, MAX_ID],
+        ['laneId', lease.laneId, MAX_ID],
+        ['conversationId', lease.conversationId, MAX_ID],
+        ['hostInstanceId', lease.hostInstanceId, MAX_ID],
+        ['runtimeProviderId', lease.runtimeProviderId, MAX_ID],
+        ['ownerSurface', lease.ownerSurface, 120],
+        ['ownerProcessStartTime', lease.ownerProcessStartTime, 128],
+        ['ownerProcessIdentity', lease.ownerProcessIdentity, 512],
+        ['workspaceEpochId', lease.workspaceEpochId, MAX_ID],
+        ['authoritySnapshotHash', lease.authoritySnapshotHash, 512],
+    ])
+        requiredString(value, field, max);
+    requiredRevision(lease.laneRevision, 'laneRevision');
+    positiveInteger(lease.leaseRevision, 'leaseRevision');
+    positiveInteger(lease.ownerPid, 'ownerPid');
+}
+function validateTransitionInput(input) {
+    if (input.lane && input.expectedRevision === undefined) {
+        throw new ProviderLaneStoreError('LANE_REVISION_CONFLICT', 'expectedRevision is required for lane mutation.');
+    }
+    if (input.expectedRevision !== undefined)
+        requiredRevision(input.expectedRevision, 'expectedRevision');
+    if (input.idempotency)
+        validateReceiptDraft(input.idempotency);
+}
+function validateReceiptDraft(receipt) {
+    requiredString(receipt.idempotencyKey, 'idempotencyKey', MAX_ID);
+    requiredString(receipt.scope, 'idempotency scope', 120);
+    requiredString(receipt.requestId, 'requestId', MAX_ID);
+    requiredHash(receipt.requestHash, 'requestHash');
+    boundedJson(receipt.response, 'idempotency response', MAX_RECEIPT_JSON);
+    if (!isRecord(receipt.response))
+        throw new Error('Idempotency response must be an object.');
+    return receipt.response;
+}
+function validateOutboxDraft(entry) {
+    requiredString(entry.outboxId, 'outboxId', MAX_ID);
+    requiredString(entry.conversationId, 'conversationId', MAX_ID);
+    requiredString(entry.laneId, 'laneId', MAX_ID);
+    requiredRevision(entry.laneRevision, 'laneRevision');
+    requiredString(entry.transitionType, 'transitionType', 120);
+    requiredString(entry.eventId, 'eventId', MAX_ID);
+    requiredString(entry.idempotencyKey, 'idempotencyKey', MAX_ID);
+    boundedJson(entry.payload, 'outbox payload', MAX_EVENT_JSON);
+}
+function boundedJson(value, field, maxBytes) {
+    const json = JSON.stringify(value);
+    if (typeof json !== 'string')
+        throw new Error(`${field} is not serializable.`);
+    if (Buffer.byteLength(json, 'utf8') > maxBytes)
+        throw new Error(`${field} exceeds ${maxBytes} bytes.`);
+    return json;
+}
+function requiredString(value, field, max) {
+    if (typeof value !== 'string')
+        throw new Error(`${field} must be a string.`);
+    const normalized = value.trim();
+    if (!normalized || Buffer.byteLength(normalized, 'utf8') > max)
+        throw new Error(`${field} is invalid.`);
+    if (normalized.includes('\u0000'))
+        throw new Error(`${field} is invalid.`);
+    return normalized;
+}
+function optionalString(value, field, max) {
+    if (value === null || value === undefined || value === '')
+        return undefined;
+    return requiredString(value, field, max);
+}
+function requiredHash(value, field) {
+    const hash = requiredString(value, field, 128);
+    if (!/^[A-Za-z0-9:_-]+$/.test(hash))
+        throw new Error(`${field} is invalid.`);
+    return hash;
+}
+function requiredRevision(value, field) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        throw new Error(`${field} is invalid.`);
+    return value;
+}
+function positiveInteger(value, field) {
+    const integer = requiredRevision(value, field);
+    if (integer < 1)
+        throw new Error(`${field} is invalid.`);
+    return integer;
+}
+function parseStringArray(value) {
+    try {
+        const parsed = JSON.parse(requiredString(value, 'stored string array', 64 * 1024));
+        if (!Array.isArray(parsed) || parsed.length > MAX_DIRECTORY_FINGERPRINTS)
+            throw new Error('invalid array');
+        return parsed.map((entry) => requiredString(entry, 'stored string array entry', 512));
+    }
+    catch {
+        throw new ProviderLaneStoreError('CONTINUATION_INVALID', 'Stored provider lane metadata is invalid.');
+    }
+}
+function parseOptionalRecord(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    try {
+        const parsed = JSON.parse(requiredString(value, 'stored JSON object', MAX_CAPABILITIES_JSON));
+        if (!isRecord(parsed))
+            throw new Error('not an object');
+        return parsed;
+    }
+    catch {
+        throw new ProviderLaneStoreError('CONTINUATION_INVALID', 'Stored provider lane metadata is invalid.');
+    }
+}
+function requireOneOf(value, choices, field) {
+    if (typeof value !== 'string' || !choices.includes(value))
+        throw new Error(`${field} is invalid.`);
+    return value;
+}
+function requireRecord(value) {
+    if (!isRecord(value))
+        throw new Error('SQLite returned an invalid row.');
+    return value;
+}
+function requireRecordOrNull(value) {
+    return value === undefined || value === null ? null : requireRecord(value);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function changes(result) {
+    return Number(result.changes ?? 0);
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function inTransaction(database, action) {
+    database.exec('BEGIN IMMEDIATE');
+    try {
+        const result = action();
+        database.exec('COMMIT');
+        return result;
+    }
+    catch (error) {
+        try {
+            database.exec('ROLLBACK');
+        }
+        catch {
+            // Preserve the original failure.
+        }
+        throw error;
+    }
+}
+function isUniqueConstraint(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /UNIQUE constraint failed|SQLITE_CONSTRAINT_UNIQUE/i.test(message);
+}
+function failure(error) {
+    if (error instanceof ProviderLaneStoreError) {
+        return { success: false, code: error.code, error: error.message };
+    }
+    if (isUniqueConstraint(error)) {
+        return { success: false, code: 'LANE_REVISION_CONFLICT', error: 'Provider lane mutation conflicted with durable state.' };
+    }
+    return { success: false, error: 'Provider lane persistence failed.' };
+}
+//# sourceMappingURL=ProviderLaneSqliteStore.js.map