@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/engine/workspaceSyncContentVersionStore.js

@@ -0,0 +1,1068 @@
+import { createHash } from 'crypto';
+import { compareWorkspaceMutationOrdering } from '../workspaceSyncSurface.js';
+import { canonicalWorkspaceSyncJson } from '../v3/canonicalWorkspaceSyncJson.js';
+export class WorkspaceSyncContentVersionConflictError extends Error {
+    code = 'WORKSPACE_SYNC_CONTENT_VERSION_CONFLICT';
+    constructor(message) {
+        super(message);
+        this.name = 'WorkspaceSyncContentVersionConflictError';
+    }
+}
+export class WorkspaceSyncContentVersionStateError extends Error {
+    code = 'WORKSPACE_SYNC_CONTENT_VERSION_STATE_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'WorkspaceSyncContentVersionStateError';
+    }
+}
+export class WorkspaceSyncContentVersionReferencedError extends Error {
+    code = 'WORKSPACE_SYNC_CONTENT_VERSION_REFERENCED';
+    constructor(versionId) {
+        super(`Workspace sync content version ${versionId} is still referenced by a published head.`);
+        this.name = 'WorkspaceSyncContentVersionReferencedError';
+    }
+}
+const VERSION_ID_PREFIX = 'content-version-v1-';
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+const MAX_GC_BACKOFF_MS = 24 * 60 * 60_000;
+const DEFAULT_ABANDONMENT_TTL_MS = 24 * 60 * 60_000;
+const ABANDONED_PREPARATION_FINAL_SWEEP_DELAY_MS = 24 * 60 * 60_000;
+const DEFAULT_RETIRED_RETENTION_MS = 7 * 24 * 60 * 60_000;
+function requiredString(value, field) {
+    const normalized = String(value || '').trim();
+    if (!normalized) {
+        throw new TypeError(`${field} is required.`);
+    }
+    return normalized;
+}
+function normalizeSha256(value) {
+    const normalized = requiredString(value, 'contentSha256').toLowerCase();
+    if (!SHA256_PATTERN.test(normalized)) {
+        throw new TypeError('contentSha256 must be a lowercase 64-character SHA-256 digest.');
+    }
+    return normalized;
+}
+function normalizeSizeBytes(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new TypeError('sizeBytes must be a non-negative safe integer.');
+    }
+    return value;
+}
+function addMilliseconds(value, milliseconds, field) {
+    const timestamp = Date.parse(requiredString(value, field));
+    if (!Number.isFinite(timestamp)) {
+        throw new TypeError(`${field} must be a valid timestamp.`);
+    }
+    return new Date(timestamp + milliseconds).toISOString();
+}
+function requireSafeWorkspaceKeySegment(workspaceId) {
+    const normalized = requiredString(workspaceId, 'workspaceId');
+    if (!/^[A-Za-z0-9._-]+$/.test(normalized)) {
+        throw new TypeError('workspaceId contains characters that are unsafe for immutable content keys.');
+    }
+    return normalized;
+}
+function normalizeIdentityInput(input) {
+    if (input.kind !== 'document' && input.kind !== 'asset') {
+        throw new TypeError('kind must be document or asset.');
+    }
+    if (input.storageProvider !== 'local' && input.storageProvider !== 'r2') {
+        throw new TypeError('storageProvider must be local or r2.');
+    }
+    return {
+        tenantId: requiredString(input.tenantId, 'tenantId'),
+        workspaceId: requiredString(input.workspaceId, 'workspaceId'),
+        kind: input.kind,
+        logicalPath: requiredString(input.logicalPath, 'logicalPath'),
+        storageProvider: input.storageProvider,
+        contentSha256: normalizeSha256(input.contentSha256),
+        sizeBytes: normalizeSizeBytes(input.sizeBytes),
+        mimeType: requiredString(input.mimeType, 'mimeType').toLowerCase(),
+    };
+}
+export function buildWorkspaceSyncContentIdentity(rawInput) {
+    const input = normalizeIdentityInput(rawInput);
+    const digest = createHash('sha256').update(canonicalWorkspaceSyncJson({
+        contract: 'workspace-sync-content-version-v1',
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        kind: input.kind,
+        logicalPath: input.logicalPath,
+        contentSha256: input.contentSha256,
+        sizeBytes: input.sizeBytes,
+        mimeType: input.mimeType,
+    }), 'utf8').digest('hex');
+    const versionId = `${VERSION_ID_PREFIX}${digest}`;
+    return {
+        versionId,
+        physicalKey: [
+            'workspaces',
+            requireSafeWorkspaceKeySegment(input.workspaceId),
+            '.sync-content',
+            'v1',
+            input.kind,
+            input.contentSha256.slice(0, 2),
+            versionId,
+        ].join('/'),
+    };
+}
+function mapVersionRow(row) {
+    return {
+        tenantId: String(row.tenant_id),
+        workspaceId: String(row.workspace_id),
+        versionId: String(row.version_id),
+        kind: String(row.kind),
+        logicalPath: String(row.logical_path),
+        storageProvider: String(row.storage_provider),
+        physicalKey: String(row.physical_key),
+        contentSha256: String(row.content_sha256),
+        sizeBytes: Number(row.size_bytes),
+        mimeType: String(row.mime_type),
+        state: String(row.state),
+        createdAt: String(row.created_at),
+        readyAt: row.ready_at == null ? null : String(row.ready_at),
+        publishedAt: row.published_at == null ? null : String(row.published_at),
+        retiredAt: row.retired_at == null ? null : String(row.retired_at),
+        gcAfter: row.gc_after == null ? null : String(row.gc_after),
+        deletedAt: row.deleted_at == null ? null : String(row.deleted_at),
+        gcAttemptCount: Number(row.gc_attempt_count || 0),
+        gcNextAttemptAt: row.gc_next_attempt_at == null ? null : String(row.gc_next_attempt_at),
+        gcLastError: row.gc_last_error == null ? null : String(row.gc_last_error),
+        preparationToken: row.preparation_token == null ? null : String(row.preparation_token),
+        preparationLeaseUntil: row.preparation_lease_until == null
+            ? null
+            : String(row.preparation_lease_until),
+        storageGeneration: Number(row.storage_generation || 0),
+        gcClaimToken: row.gc_claim_token == null ? null : String(row.gc_claim_token),
+        gcClaimLeaseUntil: row.gc_claim_lease_until == null
+            ? null
+            : String(row.gc_claim_lease_until),
+        gcCompletedClaimToken: row.gc_completed_claim_token == null
+            ? null
+            : String(row.gc_completed_claim_token),
+        gcQuarantineSweepRequired: Number(row.gc_quarantine_sweep_required || 0) === 1,
+        gcFinalSweepAfter: row.gc_final_sweep_after == null
+            ? null
+            : String(row.gc_final_sweep_after),
+    };
+}
+function mapHeadRow(row) {
+    return {
+        tenantId: String(row.tenant_id),
+        workspaceId: String(row.workspace_id),
+        kind: String(row.kind),
+        logicalPath: String(row.logical_path),
+        versionId: row.version_id == null ? null : String(row.version_id),
+        sourceUpdatedAt: String(row.source_updated_at),
+        contentSha256: row.content_sha256 == null ? null : String(row.content_sha256),
+        sizeBytes: row.size_bytes == null ? null : Number(row.size_bytes),
+        publishedAt: String(row.published_at),
+        deletedAt: row.deleted_at == null ? null : String(row.deleted_at),
+    };
+}
+function mapPreparationAttemptRow(row) {
+    return {
+        tenantId: String(row.tenant_id),
+        workspaceId: String(row.workspace_id),
+        versionId: String(row.version_id),
+        preparationToken: String(row.preparation_token),
+        storageProvider: String(row.storage_provider),
+        physicalKey: String(row.physical_key),
+        storageGeneration: Number(row.storage_generation),
+        state: String(row.state),
+        createdAt: String(row.created_at),
+        promotedAt: row.promoted_at == null ? null : String(row.promoted_at),
+        availableAfter: String(row.available_after),
+        deletedAt: row.deleted_at == null ? null : String(row.deleted_at),
+        gcAttemptCount: Number(row.gc_attempt_count || 0),
+        gcNextAttemptAt: row.gc_next_attempt_at == null ? null : String(row.gc_next_attempt_at),
+        gcLastError: row.gc_last_error == null ? null : String(row.gc_last_error),
+        gcClaimToken: row.gc_claim_token == null ? null : String(row.gc_claim_token),
+        gcClaimLeaseUntil: row.gc_claim_lease_until == null ? null : String(row.gc_claim_lease_until),
+        gcCompletedClaimToken: row.gc_completed_claim_token == null
+            ? null
+            : String(row.gc_completed_claim_token),
+    };
+}
+function sameImmutableIdentity(existing, expected) {
+    return existing.tenantId === expected.tenantId
+        && existing.workspaceId === expected.workspaceId
+        && existing.versionId === expected.versionId
+        && existing.kind === expected.kind
+        && existing.logicalPath === expected.logicalPath
+        && existing.storageProvider === expected.storageProvider
+        && matchesWorkspaceSyncContentPhysicalKey({
+            basePhysicalKey: expected.physicalKey,
+            storageGeneration: existing.storageGeneration,
+            physicalKey: existing.physicalKey,
+        })
+        && existing.contentSha256 === expected.contentSha256
+        && existing.sizeBytes === expected.sizeBytes
+        && existing.mimeType === expected.mimeType;
+}
+function buildStorageGenerationPhysicalKey(basePhysicalKey, generation) {
+    if (!Number.isSafeInteger(generation) || generation < 0) {
+        throw new WorkspaceSyncContentVersionConflictError('Workspace sync content storage generation is invalid.');
+    }
+    return generation === 0
+        ? basePhysicalKey
+        : `${basePhysicalKey}/generation-${generation}`;
+}
+export function matchesWorkspaceSyncContentPhysicalKey(input) {
+    const expectedPhysicalKey = buildStorageGenerationPhysicalKey(requiredString(input.basePhysicalKey, 'basePhysicalKey'), input.storageGeneration);
+    const physicalKey = requiredString(input.physicalKey, 'physicalKey');
+    return physicalKey === expectedPhysicalKey
+        || physicalKey.startsWith(`${expectedPhysicalKey}/attempt-`);
+}
+function buildPreparationAttemptPhysicalKey(basePhysicalKey, generation, preparationToken) {
+    const attemptDigest = createHash('sha256')
+        .update(requiredString(preparationToken, 'preparationToken'), 'utf8')
+        .digest('hex');
+    return `${buildStorageGenerationPhysicalKey(basePhysicalKey, generation)}/attempt-${attemptDigest}`;
+}
+export class WorkspaceSyncContentVersionStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    createOrValidatePreparing(rawInput) {
+        const input = normalizeIdentityInput(rawInput);
+        const deterministic = buildWorkspaceSyncContentIdentity(input);
+        if (rawInput.versionId != null && rawInput.versionId !== deterministic.versionId) {
+            throw new WorkspaceSyncContentVersionConflictError('The supplied content version id does not match its deterministic immutable identity.');
+        }
+        if (rawInput.physicalKey != null && rawInput.physicalKey !== deterministic.physicalKey) {
+            throw new WorkspaceSyncContentVersionConflictError('The supplied physical key does not match its deterministic immutable identity.');
+        }
+        const expected = {
+            ...input,
+            versionId: deterministic.versionId,
+            physicalKey: deterministic.physicalKey,
+        };
+        const abandonAfter = rawInput.abandonAfter == null
+            ? addMilliseconds(rawInput.createdAt, DEFAULT_ABANDONMENT_TTL_MS, 'createdAt')
+            : addMilliseconds(rawInput.abandonAfter, 0, 'abandonAfter');
+        const existing = this.getVersion(expected);
+        if (existing) {
+            if (!sameImmutableIdentity(existing, expected)) {
+                throw new WorkspaceSyncContentVersionConflictError(`Workspace sync content version ${expected.versionId} already has a different immutable identity.`);
+            }
+            if (existing.state === 'deleted') {
+                return this.db.transaction(() => {
+                    this.lockLogicalHead(existing, rawInput.createdAt);
+                    const current = this.requireVersion(expected);
+                    if (!sameImmutableIdentity(current, expected)) {
+                        throw new WorkspaceSyncContentVersionConflictError(`Workspace sync content version ${expected.versionId} already has a different immutable identity.`);
+                    }
+                    if (current.state !== 'deleted') {
+                        if (current.state === 'deleting') {
+                            throw new WorkspaceSyncContentVersionStateError(`Workspace sync content version ${expected.versionId} is being garbage collected.`);
+                        }
+                        return current;
+                    }
+                    const storageGeneration = current.storageGeneration + 1;
+                    const physicalKey = buildStorageGenerationPhysicalKey(deterministic.physicalKey, storageGeneration);
+                    const result = this.db.prepare(`
+                        UPDATE workspace_sync_content_versions
+                        SET state = 'preparing',
+                            physical_key = ?,
+                            storage_generation = ?,
+                            created_at = ?,
+                            ready_at = NULL,
+                            published_at = NULL,
+                            retired_at = NULL,
+                            gc_after = ?,
+                            deleted_at = NULL,
+                            gc_attempt_count = 0,
+                            gc_next_attempt_at = NULL,
+                            gc_last_error = NULL,
+                            preparation_token = NULL,
+                            preparation_lease_until = NULL,
+                            gc_claim_token = NULL,
+                            gc_claim_lease_until = NULL,
+                            gc_completed_claim_token = NULL,
+                            gc_quarantine_sweep_required = 0,
+                            gc_final_sweep_after = NULL
+                        WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+                          AND state = 'deleted' AND storage_generation = ?
+                    `).run(physicalKey, storageGeneration, requiredString(rawInput.createdAt, 'createdAt'), abandonAfter, expected.tenantId, expected.workspaceId, expected.versionId, current.storageGeneration);
+                    if (Number(result.changes || 0) !== 1) {
+                        throw new WorkspaceSyncContentVersionStateError(`Workspace sync content version ${expected.versionId} storage generation claim was lost.`);
+                    }
+                    return this.requireVersion(expected);
+                })();
+            }
+            if (existing.state === 'deleting') {
+                throw new WorkspaceSyncContentVersionStateError(`Workspace sync content version ${expected.versionId} is being garbage collected.`);
+            }
+            return existing;
+        }
+        this.db.prepare(`
+            INSERT INTO workspace_sync_content_versions (
+                tenant_id, workspace_id, version_id, kind, logical_path,
+                storage_provider, physical_key, content_sha256, size_bytes,
+                mime_type, state, created_at, gc_after
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'preparing', ?, ?)
+            ON CONFLICT (tenant_id, workspace_id, version_id) DO NOTHING
+        `).run(expected.tenantId, expected.workspaceId, expected.versionId, expected.kind, expected.logicalPath, expected.storageProvider, expected.physicalKey, expected.contentSha256, expected.sizeBytes, expected.mimeType, requiredString(rawInput.createdAt, 'createdAt'), abandonAfter);
+        const inserted = this.getVersion(expected);
+        if (!inserted || !sameImmutableIdentity(inserted, expected)) {
+            throw new WorkspaceSyncContentVersionConflictError(`Workspace sync content version ${expected.versionId} already has a different immutable identity.`);
+        }
+        return inserted;
+    }
+    getVersion(input) {
+        const row = this.db.prepare(`
+            SELECT *
+            FROM workspace_sync_content_versions
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+        `).get(input.tenantId, input.workspaceId, input.versionId);
+        return row ? mapVersionRow(row) : null;
+    }
+    claimPreparation(input) {
+        return this.db.transaction(() => {
+            const initial = this.requireVersion(input);
+            this.lockLogicalHead(initial, input.claimedAt);
+            const version = this.requireVersion(input);
+            if (version.state === 'ready' || version.state === 'published') {
+                return {
+                    version,
+                    requiresProviderPreparation: false,
+                    attemptPhysicalKey: null,
+                };
+            }
+            if (version.state === 'deleting' || version.state === 'deleted') {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} cannot be prepared from state ${version.state}.`);
+            }
+            const claimedAt = Date.parse(requiredString(input.claimedAt, 'claimedAt'));
+            const leaseUntil = addMilliseconds(input.leaseUntil, 0, 'leaseUntil');
+            const leaseUntilMs = Date.parse(leaseUntil);
+            const existingLease = version.preparationLeaseUntil == null
+                ? null
+                : Date.parse(version.preparationLeaseUntil);
+            if (!Number.isFinite(claimedAt)
+                || leaseUntilMs <= claimedAt
+                || (existingLease != null && existingLease > claimedAt
+                    && version.preparationToken !== input.preparationToken)) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} already has an active preparation claim.`);
+            }
+            const preparationToken = requiredString(input.preparationToken, 'preparationToken');
+            const deterministic = buildWorkspaceSyncContentIdentity(version);
+            const physicalKey = buildPreparationAttemptPhysicalKey(deterministic.physicalKey, version.storageGeneration, preparationToken);
+            this.db.prepare(`
+                INSERT INTO workspace_sync_content_preparation_attempts (
+                    tenant_id, workspace_id, version_id, preparation_token,
+                    storage_provider, physical_key, storage_generation, state,
+                    created_at, available_after
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, 'preparing', ?, ?)
+                ON CONFLICT (tenant_id, workspace_id, version_id, preparation_token) DO NOTHING
+            `).run(input.tenantId, input.workspaceId, input.versionId, preparationToken, version.storageProvider, physicalKey, version.storageGeneration, input.claimedAt, leaseUntil);
+            const attempt = this.requirePreparationAttempt({ ...input, preparationToken });
+            if (attempt.physicalKey !== physicalKey
+                || attempt.storageProvider !== version.storageProvider
+                || attempt.storageGeneration !== version.storageGeneration) {
+                throw new WorkspaceSyncContentVersionConflictError(`Preparation attempt ${preparationToken} already has a different immutable identity.`);
+            }
+            this.db.prepare(`
+                UPDATE workspace_sync_content_versions
+                SET state = 'preparing',
+                    retired_at = NULL,
+                    preparation_token = ?,
+                    preparation_lease_until = ?,
+                    gc_last_error = NULL,
+                    gc_next_attempt_at = NULL
+                WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+                  AND state IN ('preparing', 'retired')
+            `).run(preparationToken, leaseUntil, input.tenantId, input.workspaceId, input.versionId);
+            const claimed = this.requireVersion(input);
+            if (claimed.preparationToken !== input.preparationToken) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} preparation claim was not acquired.`);
+            }
+            return {
+                version: claimed,
+                requiresProviderPreparation: true,
+                attemptPhysicalKey: physicalKey,
+            };
+        })();
+    }
+    releasePreparation(input) {
+        return this.db.transaction(() => {
+            this.db.prepare(`
+            UPDATE workspace_sync_content_preparation_attempts
+            SET state = CASE WHEN state = 'current' THEN state ELSE 'cleanup_pending' END,
+                gc_next_attempt_at = NULL,
+                gc_last_error = NULL,
+                gc_claim_token = NULL,
+                gc_claim_lease_until = NULL,
+                gc_completed_claim_token = NULL,
+                deleted_at = NULL
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+              AND preparation_token = ?
+        `).run(input.tenantId, input.workspaceId, input.versionId, input.preparationToken);
+            this.db.prepare(`
+            UPDATE workspace_sync_content_versions
+            SET preparation_token = NULL,
+                preparation_lease_until = NULL,
+                gc_last_error = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+              AND state = 'preparing' AND preparation_token = ?
+        `).run(input.error == null ? null : String(input.error), input.tenantId, input.workspaceId, input.versionId, input.preparationToken);
+            return this.requireVersion(input);
+        })();
+    }
+    markReady(input) {
+        return this.db.transaction(() => {
+            const existing = this.requireVersion(input);
+            if (input.preparationToken != null && existing.preparationToken !== input.preparationToken) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} preparation claim does not match.`);
+            }
+            if (input.preparationToken == null && existing.preparationToken != null) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} requires its preparation claim token.`);
+            }
+            const abandonAfter = input.abandonAfter == null
+                ? addMilliseconds(input.readyAt, DEFAULT_ABANDONMENT_TTL_MS, 'readyAt')
+                : addMilliseconds(input.abandonAfter, 0, 'abandonAfter');
+            if (input.preparedPhysicalKey != null) {
+                if (input.preparationToken == null) {
+                    throw new WorkspaceSyncContentVersionStateError('A prepared physical key requires its durable preparation token.');
+                }
+                const attempt = this.requirePreparationAttempt({
+                    ...input,
+                    preparationToken: input.preparationToken,
+                });
+                if (attempt.physicalKey !== input.preparedPhysicalKey) {
+                    throw new WorkspaceSyncContentVersionStateError(`Preparation attempt ${input.preparationToken} physical key does not match.`);
+                }
+                if (attempt.storageProvider !== existing.storageProvider
+                    || attempt.storageGeneration !== existing.storageGeneration
+                    || attempt.state !== 'preparing'
+                    || existing.state !== 'preparing') {
+                    throw new WorkspaceSyncContentVersionStateError(`Preparation attempt ${input.preparationToken} cannot be promoted.`);
+                }
+                this.db.prepare(`
+                UPDATE workspace_sync_content_preparation_attempts
+                SET state = 'cleanup_pending'
+                WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+                  AND state = 'current' AND preparation_token <> ?
+            `).run(input.tenantId, input.workspaceId, input.versionId, input.preparationToken);
+                this.db.prepare(`
+                UPDATE workspace_sync_content_preparation_attempts
+                SET state = 'current',
+                    promoted_at = ?,
+                    gc_next_attempt_at = NULL,
+                    gc_last_error = NULL,
+                    gc_claim_token = NULL,
+                    gc_claim_lease_until = NULL,
+                    gc_completed_claim_token = NULL,
+                    deleted_at = NULL
+                WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+                  AND preparation_token = ? AND state = 'preparing'
+            `).run(input.readyAt, input.tenantId, input.workspaceId, input.versionId, input.preparationToken);
+            }
+            if (existing.state === 'preparing') {
+                const preparationPredicate = input.preparationToken == null
+                    ? 'preparation_token IS NULL'
+                    : 'preparation_token = ?';
+                this.db.prepare(`
+                UPDATE workspace_sync_content_versions
+                SET state = 'ready', ready_at = ?, gc_after = ?,
+                    physical_key = COALESCE(?, physical_key),
+                    gc_last_error = NULL, gc_next_attempt_at = NULL,
+                    preparation_token = NULL, preparation_lease_until = NULL
+                WHERE tenant_id = ? AND workspace_id = ? AND version_id = ? AND state = 'preparing'
+                  AND ${preparationPredicate}
+            `).run(input.readyAt, abandonAfter, input.preparedPhysicalKey ?? null, input.tenantId, input.workspaceId, input.versionId, ...(input.preparationToken == null ? [] : [input.preparationToken]));
+            }
+            else if (existing.state === 'retired') {
+                this.db.prepare(`
+                UPDATE workspace_sync_content_versions
+                SET state = 'ready',
+                    ready_at = ?,
+                    retired_at = NULL,
+                    gc_after = ?,
+                    gc_next_attempt_at = NULL,
+                    gc_last_error = NULL,
+                    preparation_token = NULL,
+                    preparation_lease_until = NULL
+                WHERE tenant_id = ? AND workspace_id = ? AND version_id = ? AND state = 'retired'
+            `).run(input.readyAt, abandonAfter, input.tenantId, input.workspaceId, input.versionId);
+            }
+            else if (!['ready', 'published'].includes(existing.state)) {
+                throw new WorkspaceSyncContentVersionStateError(`Cannot mark content version ${input.versionId} ready from state ${existing.state}.`);
+            }
+            const ready = this.requireVersion(input);
+            if (ready.state !== 'ready' && ready.state !== 'published') {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} did not reach a verified ready state.`);
+            }
+            return ready;
+        })();
+    }
+    publish(input) {
+        return this.db.transaction(() => {
+            this.lockLogicalHead(input, input.publishedAt);
+            const version = this.requireVersion(input);
+            if (version.kind !== input.kind || version.logicalPath !== input.logicalPath) {
+                throw new WorkspaceSyncContentVersionConflictError(`Content version ${input.versionId} does not belong to ${input.kind}:${input.logicalPath}.`);
+            }
+            const current = this.getHead(input);
+            if (current && this.compareHeadMutation({
+                versionId: input.versionId,
+                sourceUpdatedAt: input.sourceUpdatedAt,
+                contentSha256: version.contentSha256,
+                sizeBytes: version.sizeBytes,
+                deletedAt: null,
+            }, current) <= 0) {
+                return current;
+            }
+            if (version.state !== 'ready' && version.state !== 'published') {
+                throw new WorkspaceSyncContentVersionStateError(`Cannot publish content version ${input.versionId} from state ${version.state}.`);
+            }
+            if (current?.versionId && current.versionId !== input.versionId) {
+                this.retireVersion({
+                    ...input,
+                    versionId: current.versionId,
+                    retiredAt: input.publishedAt,
+                    gcAfter: input.retireGcAfter != null
+                        ? addMilliseconds(input.retireGcAfter, 0, 'retireGcAfter')
+                        : addMilliseconds(input.publishedAt, DEFAULT_RETIRED_RETENTION_MS, 'publishedAt'),
+                });
+            }
+            this.db.prepare(`
+                UPDATE workspace_sync_content_versions
+                SET state = 'published',
+                    published_at = COALESCE(published_at, ?),
+                    retired_at = NULL,
+                    gc_after = NULL,
+                    gc_next_attempt_at = NULL,
+                    gc_last_error = NULL,
+                    preparation_token = NULL,
+                    preparation_lease_until = NULL
+                WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+            `).run(input.publishedAt, input.tenantId, input.workspaceId, input.versionId);
+            this.upsertHead({
+                ...input,
+                contentSha256: version.contentSha256,
+                sizeBytes: version.sizeBytes,
+                deletedAt: null,
+            });
+            return this.requireHead(input);
+        })();
+    }
+    tombstone(input) {
+        return this.db.transaction(() => {
+            this.lockLogicalHead(input, input.publishedAt);
+            const current = this.getHead(input);
+            if (current && this.compareHeadMutation({
+                versionId: null,
+                sourceUpdatedAt: input.sourceUpdatedAt,
+                contentSha256: null,
+                sizeBytes: null,
+                deletedAt: input.deletedAt,
+            }, current) <= 0) {
+                return current;
+            }
+            if (current?.versionId) {
+                this.retireVersion({
+                    ...input,
+                    versionId: current.versionId,
+                    retiredAt: input.deletedAt,
+                    gcAfter: input.retireGcAfter != null
+                        ? addMilliseconds(input.retireGcAfter, 0, 'retireGcAfter')
+                        : addMilliseconds(input.publishedAt, DEFAULT_RETIRED_RETENTION_MS, 'publishedAt'),
+                });
+            }
+            this.upsertHead({
+                ...input,
+                versionId: null,
+                contentSha256: null,
+                sizeBytes: null,
+            });
+            return this.requireHead(input);
+        })();
+    }
+    resolveHead(input) {
+        const head = this.getHead(input);
+        return head ? { source: 'versioned', head } : { source: 'legacy' };
+    }
+    getHead(input) {
+        const row = this.db.prepare(`
+            SELECT *
+            FROM workspace_sync_content_heads
+            WHERE tenant_id = ? AND workspace_id = ? AND kind = ? AND logical_path = ?
+        `).get(input.tenantId, input.workspaceId, input.kind, input.logicalPath);
+        return row ? mapHeadRow(row) : null;
+    }
+    listGcCandidates(input) {
+        const limit = Math.max(0, Math.floor(input.limit));
+        if (limit === 0) {
+            return [];
+        }
+        const rows = this.db.prepare(`
+            SELECT version.*
+            FROM workspace_sync_content_versions version
+            WHERE version.tenant_id = ?
+              AND version.workspace_id = ?
+              AND (
+                  version.state IN ('ready', 'retired')
+                  OR (
+                      version.state = 'preparing'
+                      AND (
+                          version.preparation_lease_until IS NULL
+                          OR version.preparation_lease_until <= ?
+                      )
+                  )
+                  OR (
+                      version.state = 'deleting'
+                      AND (
+                          version.gc_claim_lease_until IS NULL
+                          OR version.gc_claim_lease_until <= ?
+                      )
+                  )
+              )
+              AND version.gc_after IS NOT NULL
+              AND version.gc_after <= ?
+              AND (version.gc_next_attempt_at IS NULL OR version.gc_next_attempt_at <= ?)
+              AND NOT EXISTS (
+                  SELECT 1
+                  FROM workspace_sync_content_heads head
+                  WHERE head.tenant_id = version.tenant_id
+                    AND head.workspace_id = version.workspace_id
+                    AND head.version_id = version.version_id
+              )
+            ORDER BY version.gc_after ASC, version.version_id ASC
+            LIMIT ?
+        `).all(input.tenantId, input.workspaceId, input.now, input.now, input.now, input.now, limit);
+        return rows.map(mapVersionRow);
+    }
+    listAbandonedPreparations(input) {
+        const limit = Math.max(0, Math.floor(input.limit));
+        if (limit === 0)
+            return [];
+        const rows = this.db.prepare(`
+            SELECT version.*
+            FROM workspace_sync_content_versions version
+            WHERE version.tenant_id = ?
+              AND version.workspace_id = ?
+              AND version.state = 'preparing'
+              AND version.gc_after IS NOT NULL
+              AND version.gc_after <= ?
+              AND (
+                  version.preparation_lease_until IS NULL
+                  OR version.preparation_lease_until <= ?
+              )
+              AND NOT EXISTS (
+                  SELECT 1
+                  FROM workspace_sync_content_heads head
+                  WHERE head.tenant_id = version.tenant_id
+                    AND head.workspace_id = version.workspace_id
+                    AND head.version_id = version.version_id
+              )
+            ORDER BY version.gc_after ASC, version.version_id ASC
+            LIMIT ?
+        `).all(input.tenantId, input.workspaceId, input.now, input.now, limit);
+        return rows.map(mapVersionRow);
+    }
+    isVersionReferenced(input) {
+        return Boolean(this.db.prepare(`
+            SELECT 1
+            FROM workspace_sync_content_heads
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+            LIMIT 1
+        `).get(input.tenantId, input.workspaceId, input.versionId));
+    }
+    claimGcCandidate(input) {
+        return this.db.transaction(() => {
+            const initial = this.requireVersion(input);
+            this.lockLogicalHead(initial, input.claimedAt);
+            const version = this.requireVersion(input);
+            if (this.isVersionReferenced(input)) {
+                throw new WorkspaceSyncContentVersionReferencedError(input.versionId);
+            }
+            const claimedAt = Date.parse(requiredString(input.claimedAt, 'claimedAt'));
+            const gcClaimToken = requiredString(input.gcClaimToken, 'gcClaimToken');
+            const leaseUntil = addMilliseconds(input.leaseUntil, 0, 'leaseUntil');
+            const leaseUntilMs = Date.parse(leaseUntil);
+            const gcAfter = Date.parse(String(version.gcAfter || ''));
+            const retryAt = version.gcNextAttemptAt == null
+                ? null
+                : Date.parse(version.gcNextAttemptAt);
+            if (!Number.isFinite(claimedAt)
+                || leaseUntilMs <= claimedAt
+                || !Number.isFinite(gcAfter)
+                || gcAfter > claimedAt
+                || (retryAt != null && (!Number.isFinite(retryAt) || retryAt > claimedAt))) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} is not due for garbage collection.`);
+            }
+            const currentGcLeaseUntil = version.gcClaimLeaseUntil == null
+                ? null
+                : Date.parse(version.gcClaimLeaseUntil);
+            if (version.state === 'deleting'
+                && currentGcLeaseUntil != null
+                && (!Number.isFinite(currentGcLeaseUntil) || currentGcLeaseUntil > claimedAt)
+                && version.gcClaimToken !== gcClaimToken) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} already has an active garbage-collection claim.`);
+            }
+            if (version.state === 'preparing') {
+                const preparationLeaseUntil = version.preparationLeaseUntil == null
+                    ? null
+                    : Date.parse(version.preparationLeaseUntil);
+                if (preparationLeaseUntil != null
+                    && (!Number.isFinite(preparationLeaseUntil) || preparationLeaseUntil > claimedAt)) {
+                    throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} still has an active preparation claim.`);
+                }
+                this.db.prepare(`
+                    UPDATE workspace_sync_content_versions
+                    SET state = 'deleting',
+                        preparation_token = NULL,
+                        preparation_lease_until = NULL,
+                        gc_next_attempt_at = NULL,
+                        gc_last_error = NULL,
+                        gc_claim_token = ?,
+                        gc_claim_lease_until = ?,
+                        gc_completed_claim_token = NULL,
+                        gc_quarantine_sweep_required = 1,
+                        gc_final_sweep_after = NULL
+                    WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+                      AND state = 'preparing'
+                      AND (
+                          preparation_lease_until IS NULL
+                          OR preparation_lease_until <= ?
+                      )
+                `).run(gcClaimToken, leaseUntil, input.tenantId, input.workspaceId, input.versionId, input.claimedAt);
+            }
+            else if (version.state === 'ready' || version.state === 'retired') {
+                this.db.prepare(`
+                    UPDATE workspace_sync_content_versions
+                    SET state = 'deleting',
+                        gc_next_attempt_at = NULL,
+                        gc_last_error = NULL,
+                        gc_claim_token = ?,
+                        gc_claim_lease_until = ?,
+                        gc_completed_claim_token = NULL,
+                        gc_quarantine_sweep_required = 0,
+                        gc_final_sweep_after = NULL
+                    WHERE tenant_id = ? AND workspace_id = ? AND version_id = ? AND state = ?
+                `).run(gcClaimToken, leaseUntil, input.tenantId, input.workspaceId, input.versionId, version.state);
+            }
+            else if (version.state === 'deleting') {
+                this.db.prepare(`
+                    UPDATE workspace_sync_content_versions
+                    SET gc_claim_token = ?,
+                        gc_claim_lease_until = ?,
+                        gc_next_attempt_at = NULL,
+                        gc_last_error = NULL,
+                        gc_completed_claim_token = NULL
+                    WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+                      AND state = 'deleting'
+                      AND (
+                          gc_claim_token = ?
+                          OR gc_claim_lease_until IS NULL
+                          OR gc_claim_lease_until <= ?
+                      )
+                `).run(gcClaimToken, leaseUntil, input.tenantId, input.workspaceId, input.versionId, gcClaimToken, input.claimedAt);
+            }
+            else {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} cannot enter garbage collection from state ${version.state}.`);
+            }
+            const claimed = this.requireVersion(input);
+            if (claimed.state !== 'deleting' || claimed.gcClaimToken !== gcClaimToken) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} garbage-collection claim was not acquired.`);
+            }
+            return claimed;
+        })();
+    }
+    recordGcFailure(input) {
+        const version = this.requireGcClaim(input);
+        const nextAttempt = new Date(Date.parse(input.failedAt) + Math.min(MAX_GC_BACKOFF_MS, 1_000 * (2 ** Math.min(version.gcAttemptCount, 16)))).toISOString();
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_content_versions
+            SET gc_attempt_count = gc_attempt_count + 1,
+                gc_next_attempt_at = ?,
+                gc_last_error = ?,
+                gc_claim_token = NULL,
+                gc_claim_lease_until = NULL,
+                gc_completed_claim_token = NULL
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+              AND state = 'deleting' AND gc_claim_token = ?
+        `).run(nextAttempt, requiredString(input.error, 'error'), input.tenantId, input.workspaceId, input.versionId, input.gcClaimToken);
+        if (Number(result.changes || 0) !== 1) {
+            throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} garbage-collection failure claim was lost.`);
+        }
+        return this.requireVersion(input);
+    }
+    markDeleted(input) {
+        const version = this.requireVersion(input);
+        if (version.state === 'deleted') {
+            if (version.gcCompletedClaimToken === input.gcClaimToken) {
+                return version;
+            }
+            throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} was completed by a different garbage-collection claim.`);
+        }
+        this.requireGcClaim(input);
+        const deletedAt = Date.parse(requiredString(input.deletedAt, 'deletedAt'));
+        const finalSweepAfter = version.gcFinalSweepAfter == null
+            ? null
+            : Date.parse(version.gcFinalSweepAfter);
+        if (!Number.isFinite(deletedAt) || (finalSweepAfter != null && !Number.isFinite(finalSweepAfter))) {
+            throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} has invalid garbage-collection sweep timing.`);
+        }
+        if (version.gcQuarantineSweepRequired && finalSweepAfter == null) {
+            const scheduledFinalSweep = addMilliseconds(input.deletedAt, ABANDONED_PREPARATION_FINAL_SWEEP_DELAY_MS, 'deletedAt');
+            const quarantined = this.db.prepare(`
+                UPDATE workspace_sync_content_versions
+                SET gc_next_attempt_at = ?,
+                    gc_last_error = NULL,
+                    gc_claim_token = NULL,
+                    gc_claim_lease_until = NULL,
+                    gc_completed_claim_token = NULL,
+                    gc_final_sweep_after = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+                  AND state = 'deleting' AND gc_claim_token = ?
+            `).run(scheduledFinalSweep, scheduledFinalSweep, input.tenantId, input.workspaceId, input.versionId, input.gcClaimToken);
+            if (Number(quarantined.changes || 0) !== 1) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} garbage-collection quarantine claim was lost.`);
+            }
+            return this.requireVersion(input);
+        }
+        if (finalSweepAfter != null && finalSweepAfter > deletedAt) {
+            const deferred = this.db.prepare(`
+                UPDATE workspace_sync_content_versions
+                SET gc_next_attempt_at = ?,
+                    gc_last_error = NULL,
+                    gc_claim_token = NULL,
+                    gc_claim_lease_until = NULL,
+                    gc_completed_claim_token = NULL
+                WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+                  AND state = 'deleting' AND gc_claim_token = ?
+            `).run(version.gcFinalSweepAfter, input.tenantId, input.workspaceId, input.versionId, input.gcClaimToken);
+            if (Number(deferred.changes || 0) !== 1) {
+                throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} garbage-collection deferral claim was lost.`);
+            }
+            return this.requireVersion(input);
+        }
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_content_versions
+            SET state = 'deleted',
+                deleted_at = ?,
+                gc_next_attempt_at = NULL,
+                gc_last_error = NULL,
+                gc_claim_token = NULL,
+                gc_claim_lease_until = NULL,
+                gc_completed_claim_token = ?,
+                gc_quarantine_sweep_required = 0,
+                gc_final_sweep_after = NULL
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+              AND state = 'deleting' AND gc_claim_token = ?
+        `).run(input.deletedAt, input.gcClaimToken, input.tenantId, input.workspaceId, input.versionId, input.gcClaimToken);
+        if (Number(result.changes || 0) !== 1) {
+            throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} garbage-collection completion claim was lost.`);
+        }
+        return this.requireVersion(input);
+    }
+    listPreparationAttemptGcCandidates(input) {
+        const limit = Math.max(0, Math.floor(input.limit));
+        if (limit === 0)
+            return [];
+        const rows = this.db.prepare(`
+            SELECT attempt.*
+            FROM workspace_sync_content_preparation_attempts attempt
+            WHERE attempt.tenant_id = ?
+              AND attempt.workspace_id = ?
+              AND attempt.state IN ('preparing', 'cleanup_pending', 'deleting')
+              AND attempt.available_after <= ?
+              AND (attempt.gc_next_attempt_at IS NULL OR attempt.gc_next_attempt_at <= ?)
+              AND (attempt.gc_claim_lease_until IS NULL OR attempt.gc_claim_lease_until <= ?)
+              AND NOT EXISTS (
+                  SELECT 1
+                  FROM workspace_sync_content_versions version
+                  WHERE version.tenant_id = attempt.tenant_id
+                    AND version.workspace_id = attempt.workspace_id
+                    AND version.version_id = attempt.version_id
+                    AND version.physical_key = attempt.physical_key
+                    AND version.state <> 'deleted'
+              )
+            ORDER BY attempt.available_after ASC, attempt.version_id ASC, attempt.preparation_token ASC
+            LIMIT ?
+        `).all(input.tenantId, input.workspaceId, input.now, input.now, input.now, limit);
+        return rows.map(mapPreparationAttemptRow);
+    }
+    claimPreparationAttemptGc(input) {
+        const gcClaimToken = requiredString(input.gcClaimToken, 'gcClaimToken');
+        const claimedAt = addMilliseconds(input.claimedAt, 0, 'claimedAt');
+        const leaseUntil = addMilliseconds(input.leaseUntil, 0, 'leaseUntil');
+        if (Date.parse(leaseUntil) <= Date.parse(claimedAt)) {
+            throw new WorkspaceSyncContentVersionStateError('Preparation-attempt garbage-collection lease must end after it starts.');
+        }
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_content_preparation_attempts
+            SET state = 'deleting',
+                gc_claim_token = ?,
+                gc_claim_lease_until = ?,
+                gc_next_attempt_at = NULL,
+                gc_last_error = NULL
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+              AND preparation_token = ?
+              AND state IN ('preparing', 'cleanup_pending', 'deleting')
+              AND available_after <= ?
+              AND (gc_next_attempt_at IS NULL OR gc_next_attempt_at <= ?)
+              AND (
+                  gc_claim_lease_until IS NULL
+                  OR gc_claim_lease_until <= ?
+                  OR gc_claim_token = ?
+              )
+              AND NOT EXISTS (
+                  SELECT 1
+                  FROM workspace_sync_content_versions version
+                  WHERE version.tenant_id = workspace_sync_content_preparation_attempts.tenant_id
+                    AND version.workspace_id = workspace_sync_content_preparation_attempts.workspace_id
+                    AND version.version_id = workspace_sync_content_preparation_attempts.version_id
+                    AND version.physical_key = workspace_sync_content_preparation_attempts.physical_key
+                    AND version.state <> 'deleted'
+              )
+        `).run(gcClaimToken, leaseUntil, input.tenantId, input.workspaceId, input.versionId, input.preparationToken, claimedAt, claimedAt, claimedAt, gcClaimToken);
+        if (Number(result.changes || 0) !== 1) {
+            throw new WorkspaceSyncContentVersionStateError(`Preparation attempt ${input.preparationToken} is not eligible for garbage collection.`);
+        }
+        return this.requirePreparationAttempt(input);
+    }
+    recordPreparationAttemptGcFailure(input) {
+        const attempt = this.requirePreparationAttempt(input);
+        if (attempt.state !== 'deleting' || attempt.gcClaimToken !== input.gcClaimToken) {
+            throw new WorkspaceSyncContentVersionStateError(`Preparation attempt ${input.preparationToken} garbage-collection claim does not match.`);
+        }
+        const nextAttemptAt = new Date(Date.parse(input.failedAt) + Math.min(MAX_GC_BACKOFF_MS, 1_000 * (2 ** Math.min(attempt.gcAttemptCount, 16)))).toISOString();
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_content_preparation_attempts
+            SET state = 'cleanup_pending',
+                gc_attempt_count = gc_attempt_count + 1,
+                gc_next_attempt_at = ?,
+                gc_last_error = ?,
+                gc_claim_token = NULL,
+                gc_claim_lease_until = NULL
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+              AND preparation_token = ? AND gc_claim_token = ?
+        `).run(nextAttemptAt, requiredString(input.error, 'error'), input.tenantId, input.workspaceId, input.versionId, input.preparationToken, input.gcClaimToken);
+        if (Number(result.changes || 0) !== 1) {
+            throw new WorkspaceSyncContentVersionStateError(`Preparation attempt ${input.preparationToken} garbage-collection failure claim was lost.`);
+        }
+        return this.requirePreparationAttempt(input);
+    }
+    completePreparationAttemptGc(input) {
+        const existing = this.requirePreparationAttempt(input);
+        if (existing.state === 'deleted'
+            && existing.gcCompletedClaimToken === input.gcClaimToken) {
+            return;
+        }
+        const result = this.db.prepare(`
+            UPDATE workspace_sync_content_preparation_attempts
+            SET state = 'deleted',
+                deleted_at = ?,
+                gc_next_attempt_at = NULL,
+                gc_last_error = NULL,
+                gc_claim_token = NULL,
+                gc_claim_lease_until = NULL,
+                gc_completed_claim_token = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+              AND preparation_token = ? AND state = 'deleting' AND gc_claim_token = ?
+        `).run(addMilliseconds(input.deletedAt, 0, 'deletedAt'), input.gcClaimToken, input.tenantId, input.workspaceId, input.versionId, input.preparationToken, input.gcClaimToken);
+        if (Number(result.changes || 0) !== 1) {
+            throw new WorkspaceSyncContentVersionStateError(`Preparation attempt ${input.preparationToken} garbage-collection completion claim was lost.`);
+        }
+    }
+    requireVersion(input) {
+        const version = this.getVersion(input);
+        if (!version) {
+            throw new WorkspaceSyncContentVersionStateError(`Workspace sync content version ${input.versionId} was not found.`);
+        }
+        return version;
+    }
+    requirePreparationAttempt(input) {
+        const row = this.db.prepare(`
+            SELECT *
+            FROM workspace_sync_content_preparation_attempts
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+              AND preparation_token = ?
+        `).get(input.tenantId, input.workspaceId, input.versionId, input.preparationToken);
+        if (!row) {
+            throw new WorkspaceSyncContentVersionStateError(`Preparation attempt ${input.preparationToken} does not exist.`);
+        }
+        return mapPreparationAttemptRow(row);
+    }
+    lockLogicalHead(input, updatedAt) {
+        const domain = `content-head:${createHash('sha256')
+            .update(canonicalWorkspaceSyncJson({ kind: input.kind, logicalPath: input.logicalPath }), 'utf8')
+            .digest('hex')}`;
+        this.db.prepare(`
+            INSERT INTO workspace_sync_domain_locks (
+                tenant_id, workspace_id, domain, updated_at
+            ) VALUES (?, ?, ?, ?)
+            ON CONFLICT (tenant_id, workspace_id, domain) DO UPDATE SET
+                updated_at = excluded.updated_at
+        `).run(input.tenantId, input.workspaceId, domain, updatedAt);
+        if (this.db.provider === 'postgres') {
+            this.db.prepare(`
+                SELECT domain
+                FROM workspace_sync_domain_locks
+                WHERE tenant_id = ? AND workspace_id = ? AND domain = ?
+                FOR UPDATE
+            `).get(input.tenantId, input.workspaceId, domain);
+        }
+    }
+    requireGcClaim(input) {
+        const version = this.requireVersion(input);
+        if (this.isVersionReferenced(input)) {
+            throw new WorkspaceSyncContentVersionReferencedError(input.versionId);
+        }
+        if (version.state !== 'deleting') {
+            throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} has not been claimed for garbage collection.`);
+        }
+        if (version.gcClaimToken !== input.gcClaimToken) {
+            throw new WorkspaceSyncContentVersionStateError(`Content version ${input.versionId} garbage-collection claim does not match.`);
+        }
+        return version;
+    }
+    retireVersion(input) {
+        const version = this.requireVersion(input);
+        if (version.state !== 'published' && version.state !== 'retired') {
+            throw new WorkspaceSyncContentVersionStateError(`Cannot retire content version ${input.versionId} from state ${version.state}.`);
+        }
+        this.db.prepare(`
+            UPDATE workspace_sync_content_versions
+            SET state = 'retired',
+                retired_at = COALESCE(retired_at, ?),
+                gc_after = COALESCE(gc_after, ?)
+            WHERE tenant_id = ? AND workspace_id = ? AND version_id = ?
+        `).run(input.retiredAt, input.gcAfter, input.tenantId, input.workspaceId, input.versionId);
+    }
+    upsertHead(input) {
+        this.db.prepare(`
+            INSERT INTO workspace_sync_content_heads (
+                tenant_id, workspace_id, kind, logical_path, version_id,
+                source_updated_at, content_sha256, size_bytes, published_at, deleted_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (tenant_id, workspace_id, kind, logical_path) DO UPDATE SET
+                version_id = excluded.version_id,
+                source_updated_at = excluded.source_updated_at,
+                content_sha256 = excluded.content_sha256,
+                size_bytes = excluded.size_bytes,
+                published_at = excluded.published_at,
+                deleted_at = excluded.deleted_at
+        `).run(input.tenantId, input.workspaceId, input.kind, input.logicalPath, input.versionId, input.sourceUpdatedAt, input.contentSha256, input.sizeBytes, input.publishedAt, input.deletedAt);
+    }
+    requireHead(input) {
+        const head = this.getHead(input);
+        if (!head) {
+            throw new Error(`Workspace sync content head ${input.kind}:${input.logicalPath} was not written.`);
+        }
+        return head;
+    }
+    compareHeadMutation(incoming, existing) {
+        const tieBreak = (value) => canonicalWorkspaceSyncJson({
+            versionId: value.versionId,
+            contentSha256: value.contentSha256,
+            sizeBytes: value.sizeBytes,
+            deletedAt: value.deletedAt,
+        });
+        return compareWorkspaceMutationOrdering(incoming.sourceUpdatedAt, existing.sourceUpdatedAt, tieBreak(incoming), tieBreak(existing));
+    }
+}