@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/sync/v3/syncDurabilityStore.d.ts

@@ -0,0 +1,781 @@
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
+export { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+export { fingerprintWorkspaceSyncPayload } from './workspaceSyncPayloadFingerprint.js';
+export declare const WORKSPACE_SYNC_CONTRACT_VERSION = 3;
+export declare const WORKSPACE_SYNC_INITIATIVE_PROJECTION_LOCK = "projection:initiative/full-v1";
+export declare const WORKSPACE_SYNC_COMBINED_PROJECTION = "coverage/task-planning-metadata-v1";
+export declare const WORKSPACE_SYNC_COMBINED_PROJECTION_LOCK = "workspace-sync-v3-combined-projection";
+export type WorkspaceSyncOperationIdentity = {
+    tenantId: string;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+};
+export type WorkspaceSyncOperationReservation = {
+    state: 'owned';
+    leaseOwner: string;
+} | {
+    state: 'in_progress';
+    retryAt: string;
+} | {
+    state: 'committed';
+    responseJson: string;
+    acceptedSequence: string | null;
+};
+export type WorkspaceSyncRevisionKind = 'metadata' | 'lifecycle' | 'both';
+export type WorkspaceSyncAcceptedRevision = {
+    domain: string;
+    entityId: string;
+    sequence: string;
+    entityRevision: string;
+    lifecycleRevision: string;
+};
+export type WorkspaceSyncEntityRevisionCoordinates = {
+    entityRevision: string;
+    lifecycleRevision: string;
+};
+export type WorkspaceSyncDomainOwnership = WorkspaceSyncEntityRevisionCoordinates & {
+    domain: string;
+    entityId: string;
+    activeOperation: boolean;
+    owned: boolean;
+    lastSequence: string | null;
+    canonicalFingerprint: string | null;
+};
+export type WorkspaceSyncProjectionOwnership = {
+    owner: 'v2' | 'v3';
+    epoch: string;
+};
+export type WorkspaceSyncBatchJournalEntry<T> = {
+    domain: string;
+    entityId: string;
+    mutationKind: string;
+    revisionKind: WorkspaceSyncRevisionKind;
+    contentSha256?: string | null;
+    sizeBytes?: string | number | null;
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+    /**
+     * `current` is reserved for commutative operations such as stable-ID
+     * append. It advances from the locked current revision while still
+     * rejecting impossible client coordinates ahead of authority.
+     */
+    baseRevisionPolicy?: 'exact' | 'current';
+    include?: (mutationResult: T) => boolean;
+    buildCanonicalFingerprint: (mutationResult: T, revision: WorkspaceSyncAcceptedRevision) => string;
+    buildAuthoritativePayload: (mutationResult: T, revision: WorkspaceSyncAcceptedRevision) => unknown;
+    metadataOwned?: (mutationResult: T) => boolean;
+    reopenAssigneeOwned?: (mutationResult: T) => boolean;
+};
+export type WorkspaceSyncOutboxDispatchClass = 'ordinary' | 'legacy-adoption';
+export type WorkspaceSyncOutboxRecord = WorkspaceSyncOperationIdentity & {
+    dispatchClass: WorkspaceSyncOutboxDispatchClass;
+    domain: string;
+    entityId: string;
+    mutationKind: string;
+    ownsTaskMetadata: boolean;
+    ownsTaskLifecycle: boolean;
+    ownsTaskAssignee: boolean;
+    baseEntityRevision: string;
+    baseLifecycleRevision: string;
+    payloadJson: string;
+    payloadFingerprint: string;
+    status: string;
+    attemptCount: number;
+    initialNotFoundAttemptCount: number;
+    enqueueSequence: string;
+    rebaseBeforeFirstAttempt: boolean;
+    workstreamMetadataRevisionRebaseCount?: number;
+    initiativeMetadataRevisionRebaseCount?: number;
+    leaseOwner: string | null;
+    leaseExpiresAt: string | null;
+};
+export type WorkspaceSyncOutboxSupersession = {
+    recoveryBatchId: string;
+    operationIds: string[];
+};
+export type WorkspaceSyncOutboxRecoveryReplay = {
+    recoveryBatchId: string;
+    operationIds: string[];
+};
+export type WorkspaceSyncOutboxRecoveryState = 'awaiting_baseline' | 'baseline_ready' | 'replay_queued' | 'completed';
+export type WorkspaceSyncOutboxRecovery = {
+    recoveryBatchId: string;
+    rootClientId: string;
+    rootOperationId: string;
+    state: WorkspaceSyncOutboxRecoveryState;
+    baselineMarker: string | null;
+    replayTotal: number;
+    replayPending: number;
+    replayInFlight: number;
+    replayBlocked: number;
+    replayAccepted: number;
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+};
+export type WorkspaceSyncV3DispatchSettlementEvidence = {
+    kind: 'accepted';
+    acceptedSequence: string | null;
+} | {
+    kind: 'completed-recovery';
+    recoveryBatchId: string;
+    baselineMarker: string;
+    completedAt: string;
+};
+export type WorkspaceSyncOutboxTarget = {
+    domain: string;
+    entityId: string;
+    mutationKind: string;
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+    ownsTaskMetadata?: boolean;
+    ownsTaskLifecycle?: boolean;
+    ownsTaskAssignee?: boolean;
+};
+export type WorkspaceSyncTaskMetadataOwnership = {
+    taskId: string;
+    activeOperation: boolean;
+    activeCreateOperation: boolean;
+    activeDeleteOperation?: boolean;
+    deleteOwned?: boolean;
+    metadataOwned: boolean;
+    activeLifecycleOperation?: boolean;
+    activeReopenOperation?: boolean;
+    reopenAssigneeOwned?: boolean;
+    entityRevision: string | null;
+    lifecycleRevision: string | null;
+    lastSequence: string | null;
+};
+export type WorkspaceSyncTaskMetadataCoexistenceDirection = 'cloud-push' | 'local-pull';
+export type WorkspaceSyncDomainCoexistenceTarget = {
+    domain: string;
+    entityId: string;
+};
+export type WorkspaceSyncRecoveryBaselineTarget = WorkspaceSyncDomainCoexistenceTarget & {
+    required: boolean;
+};
+export type WorkspaceSyncPlanningRevisionProjection = {
+    entityId: string;
+    coexistenceOwned: boolean;
+    mutationKind: 'create' | 'metadata-update' | 'append-comment' | 'archive' | 'unarchive';
+    entityRevision: string;
+    lifecycleRevision: string;
+    lastSequence: string;
+    canonicalFingerprint: string;
+    occurredAt: string;
+};
+export type WorkspaceSyncInitiativeBaseline = {
+    entityId: string;
+    activePayload: unknown;
+    currentPayload: unknown;
+    currentFingerprint: string;
+    occurredAt: string;
+    archived: boolean;
+};
+export declare class WorkspaceSyncIdempotencyConflictError extends Error {
+    readonly code = "WORKSPACE_SYNC_IDEMPOTENCY_CONFLICT";
+    readonly statusCode = 409;
+    constructor();
+}
+export declare class WorkspaceSyncPlanningOwnershipChangedError extends Error {
+    readonly code = "WORKSPACE_SYNC_PLANNING_OWNERSHIP_CHANGED";
+    readonly statusCode = 409;
+    constructor();
+}
+export declare class WorkspaceSyncLeaseLostError extends Error {
+    readonly code = "WORKSPACE_SYNC_LEASE_LOST";
+    constructor();
+}
+export declare class WorkspaceSyncRevisionConflictError extends Error {
+    readonly code = "WORKSPACE_SYNC_REVISION_CONFLICT";
+    readonly statusCode = 409;
+    readonly details?: Record<string, unknown>;
+    constructor(details?: Record<string, unknown>);
+}
+export declare class WorkspaceSyncEntityBusyError extends Error {
+    readonly code = "WORKSPACE_SYNC_ENTITY_BUSY";
+    readonly statusCode = 409;
+    readonly details?: Record<string, unknown>;
+    readonly retryable: boolean;
+    readonly retryAfterAt?: string;
+    readonly retryHint: string;
+    constructor(input?: {
+        details?: Record<string, unknown>;
+        retryable?: boolean;
+        retryAfterAt?: string;
+        retryHint?: string;
+    });
+}
+export type WorkspaceSyncActiveOperationState = 'pending' | 'retry-scheduled' | 'in-flight' | 'stale' | 'blocked';
+export declare function resolveWorkspaceSyncActiveOperationState(input: {
+    status: unknown;
+    nextAttemptAt?: unknown;
+    leaseExpiresAt?: unknown;
+    now: string;
+}): WorkspaceSyncActiveOperationState;
+/**
+ * Authoritative feed apply may replace a provisional entity event only after
+ * durable recovery has explicitly superseded the operation that created it.
+ * Persisted targets or a recognized deterministic task-root identity provide
+ * the provenance proof; arbitrary same-ID conflicts continue to fail closed.
+ */
+export declare function hasCompletedRecoveryForSupersededEntityEvent(db: DatabaseAdapter, input: {
+    tenantId: string;
+    workspaceId: string;
+    entityType: string;
+    entityId: string;
+    eventId: string;
+}): boolean;
+export declare class WorkspaceSyncDurabilityStore {
+    private readonly db;
+    private readonly journalReader;
+    constructor(db: DatabaseAdapter);
+    readEntityRevisionCoordinates(input: {
+        tenantId: string;
+        workspaceId: string;
+        domain: string;
+        entityId: string;
+    }): WorkspaceSyncEntityRevisionCoordinates;
+    readInitiativeProjectionOwnership(input: {
+        tenantId: string;
+        workspaceId: string;
+    }): WorkspaceSyncProjectionOwnership;
+    readCombinedProjectionOwnership(input: {
+        tenantId: string;
+        workspaceId: string;
+    }): WorkspaceSyncProjectionOwnership;
+    runCombinedProjectionTransaction<T>(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+        apply: (ownership: WorkspaceSyncProjectionOwnership) => T;
+    }): T;
+    readWorkspaceDomainOwnership(input: {
+        tenantId: string;
+        workspaceId: string;
+        domain: string;
+        entityId: string;
+    }): WorkspaceSyncDomainOwnership;
+    listWorkspaceDomainOwnership(input: {
+        tenantId: string;
+        workspaceId: string;
+        domain: string;
+        entityIds: string[];
+    }): WorkspaceSyncDomainOwnership[];
+    listOwnedWorkspaceDomainRevisionsAfter(input: {
+        tenantId: string;
+        workspaceId: string;
+        domains: string[];
+        sequence: string;
+    }): Array<{
+        domain: string;
+        entityId: string;
+        lastSequence: string;
+    }>;
+    applyReplicatedEntityRevision<T>(input: {
+        tenantId: string;
+        workspaceId: string;
+        domain: string;
+        entityId: string;
+        sequence: string | number;
+        entityRevision: string | number;
+        lifecycleRevision: string | number;
+        canonicalFingerprint: string;
+        now: string;
+        metadataOwned?: boolean;
+        reopenAssigneeOwned?: boolean;
+        allowAuthoritativeEqualRevisionReplacement?: boolean;
+        allowAuthoritativeRevisionReset?: boolean;
+        applyMutation: () => T;
+        shouldRecordRevision?: (result: T) => boolean;
+    }): {
+        state: 'applied';
+        result: T;
+    } | {
+        state: 'deferred';
+        result: T;
+    } | {
+        state: 'current' | 'stale';
+    };
+    runLocalTaskDeleteCaptureTransaction<T>(input: {
+        tenantId: string;
+        workspaceId: string;
+        taskId: string;
+        now: string;
+        apply: () => T;
+    }): T;
+    runLocalTaskRestoreCaptureTransaction<T>(input: {
+        tenantId: string;
+        workspaceId: string;
+        taskId: string;
+        now: string;
+        apply: () => T;
+    }): T;
+    readOperation(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        requestFingerprint: string;
+    }): Extract<WorkspaceSyncOperationReservation, {
+        state: 'in_progress' | 'committed';
+    }> | null;
+    readCommittedOperationResponse(identity: WorkspaceSyncOperationIdentity): string | null;
+    readOperationReservationMetadata(identity: WorkspaceSyncOperationIdentity): {
+        status: 'processing' | 'committed';
+        createdAt: string;
+    } | null;
+    readOutboxOperation(identity: WorkspaceSyncOperationIdentity): WorkspaceSyncOutboxRecord | null;
+    readV3DispatchSettlementEvidence(identity: WorkspaceSyncOperationIdentity): WorkspaceSyncV3DispatchSettlementEvidence | null;
+    listBlockedInvalidOutboxOperations(input: {
+        tenantId: string;
+        workspaceId: string;
+        limit?: number;
+    }): WorkspaceSyncOutboxRecord[];
+    requeueBlockedInvalidOutboxOperation(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        now: string;
+    }): boolean;
+    requeueAcceptedV3DispatchOperation(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        now: string;
+    }): boolean;
+    requeueWorkstreamInitiativeDependencyAcknowledgements(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    readWorkflowAssignmentDependencyState(input: {
+        tenantId: string;
+        workspaceId: string;
+        executionId: string;
+        beforeEnqueueSequence: string | number;
+    }): 'pending' | 'blocked' | null;
+    getActiveEntityBusyError(input: {
+        tenantId: string;
+        workspaceId: string;
+        target: WorkspaceSyncDomainCoexistenceTarget;
+        now: string;
+        mutationKind?: string;
+    }): WorkspaceSyncEntityBusyError | null;
+    hasActiveOutboxSuccessor(identity: WorkspaceSyncOperationIdentity): boolean;
+    listActiveOutboxSuccessors(identity: WorkspaceSyncOperationIdentity): WorkspaceSyncOutboxRecord[];
+    supersedeBlockedOutboxChain(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        recoveryBatchId: string;
+        now: string;
+        replayPolicy?: 'task-root';
+        appendToExistingRecovery?: boolean;
+    }): WorkspaceSyncOutboxSupersession;
+    recordOutboxRecoveryBaseline(input: {
+        tenantId: string;
+        workspaceId: string;
+        recoveryBatchId: string;
+        baselineMarker: string;
+        now: string;
+    }): void;
+    listOutboxRecoveryTargets(input: {
+        tenantId: string;
+        workspaceId: string;
+        recoveryBatchId: string;
+    }): WorkspaceSyncDomainCoexistenceTarget[];
+    listOutboxRecoveryBaselineTargets(input: {
+        tenantId: string;
+        workspaceId: string;
+        recoveryBatchId: string;
+    }): WorkspaceSyncRecoveryBaselineTarget[];
+    prepareTaskRootOutboxRecoveryReplay(input: {
+        tenantId: string;
+        workspaceId: string;
+        recoveryBatchId: string;
+        now: string;
+    }): WorkspaceSyncOutboxRecoveryReplay;
+    readOpenOutboxRecovery(input: {
+        tenantId: string;
+        workspaceId: string;
+    }): WorkspaceSyncOutboxRecovery | null;
+    readOutboxRecovery(input: {
+        tenantId: string;
+        workspaceId: string;
+        recoveryBatchId: string;
+    }): WorkspaceSyncOutboxRecovery | null;
+    findOldestBlockedOutboxIdentity(input: {
+        tenantId: string;
+        workspaceId: string;
+    }): WorkspaceSyncOperationIdentity | null;
+    listBlockedOutboxIdentities(input: {
+        tenantId: string;
+        workspaceId: string;
+    }): WorkspaceSyncOperationIdentity[];
+    restartOutboxRecoveryAfterRebaseConflict(input: {
+        tenantId: string;
+        workspaceId: string;
+        recoveryBatchId: string;
+        now: string;
+    }): boolean;
+    completeOutboxRecoveryIfSettled(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): WorkspaceSyncOutboxRecovery | null;
+    private mapOutboxRecovery;
+    readOperationStateForUpdate(identity: WorkspaceSyncOperationIdentity): {
+        status: 'processing' | 'committed';
+        responseJson: string | null;
+        createdAt: string;
+    } | null;
+    readCreateDependencyState(input: {
+        tenantId: string;
+        workspaceId: string;
+        dependencies: ReadonlyArray<{
+            domain: string;
+            entityId: string;
+        }>;
+    }): 'pending' | 'blocked' | null;
+    readTaskCreateDependencyState(input: {
+        tenantId: string;
+        workspaceId: string;
+        taskIds: readonly string[];
+    }): 'pending' | 'blocked' | null;
+    listActiveTaskRelationshipOperationIds(input: {
+        tenantId: string;
+        workspaceId: string;
+    }): string[];
+    listAttachmentAssetIdsAwaitingContentPublication(input: {
+        tenantId: string;
+        workspaceId: string;
+    }): string[];
+    runTaskRelationshipCoexistenceTransaction<T>(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+        apply: (activeRelationshipIds: string[]) => T;
+    }): T;
+    reserveOperation(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        requestFingerprint: string;
+        now: string;
+        leaseExpiresAt: string;
+        leaseOwner?: string;
+    }): WorkspaceSyncOperationReservation;
+    releaseFailedOperationReservation(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        requestFingerprint: string;
+        leaseOwner: string;
+        now: string;
+    }): void;
+    commitReservedOperationResponse(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        requestFingerprint: string;
+        leaseOwner: string;
+        now: string;
+        response: unknown;
+    }): {
+        responseJson: string;
+    };
+    acceptReservedOperation<T>(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        requestFingerprint: string;
+        leaseOwner: string;
+        now: string;
+        domain: string;
+        entityId: string;
+        mutationKind: string;
+        revisionKind: WorkspaceSyncRevisionKind;
+        contentSha256?: string | null;
+        sizeBytes?: string | number | null;
+        baseEntityRevision: string | number;
+        baseLifecycleRevision: string | number;
+        applyMutation: () => T;
+        buildCanonicalFingerprint: (mutationResult: T) => string;
+        buildAuthoritativePayload: (mutationResult: T, revision: {
+            sequence: string;
+            entityRevision: string;
+            lifecycleRevision: string;
+        }) => unknown;
+        buildResponse: (mutationResult: T, revision: {
+            sequence: string;
+            entityRevision: string;
+            lifecycleRevision: string;
+        }) => unknown;
+        metadataOwned?: (mutationResult: T) => boolean;
+        reopenAssigneeOwned?: (mutationResult: T) => boolean;
+    }): {
+        responseJson: string;
+        acceptedSequence: string;
+    };
+    acceptReservedOperationBatch<T>(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        requestFingerprint: string;
+        leaseOwner: string;
+        now: string;
+        entries: Array<WorkspaceSyncBatchJournalEntry<T>>;
+        applyMutation: () => T;
+        buildResponse: (mutationResult: T, revisions: WorkspaceSyncAcceptedRevision[]) => unknown;
+    }): {
+        responseJson: string;
+        acceptedSequence: string;
+    };
+    enqueueLocalOperation<T>(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        dispatchClass?: WorkspaceSyncOutboxDispatchClass;
+        domain: string;
+        entityId: string;
+        mutationKind: string;
+        baseEntityRevision?: string | number;
+        baseLifecycleRevision?: string | number;
+        revisionSource?: 'explicit' | 'current';
+        ownership?: {
+            taskMetadata?: boolean;
+            taskLifecycle?: boolean;
+            taskAssignee?: boolean;
+        };
+        additionalTargets?: WorkspaceSyncOutboxTarget[];
+        payload: unknown;
+        now: string;
+        applyLocalMutation: () => T;
+        requireV3PlanningOwnership?: 'initiative' | 'workstream' | 'combined';
+        requiredCurrentRevision?: {
+            entityRevision: string | number;
+            lifecycleRevision: string | number;
+        };
+        validateLockedState?: () => void;
+        queuedMetadataSuccessorDomain?: 'task' | 'workstream';
+        queuedTaskSuccessor?: boolean;
+        queuedWorkflowRuntimeSuccessor?: boolean;
+        coalesceWorkflowAssignmentExecutionId?: string;
+    }): {
+        enqueued: boolean;
+        mutationResult?: T;
+    };
+    listTaskMetadataOwnership(input: {
+        tenantId: string;
+        workspaceId: string;
+    }): WorkspaceSyncTaskMetadataOwnership[];
+    listTaskRevisionProjections(input: {
+        tenantId: string;
+        workspaceId: string;
+        taskIds: string[];
+    }): Array<{
+        taskId: string;
+        entityRevision: string;
+        lifecycleRevision: string;
+        lastSequence: string;
+        canonicalFingerprint: string;
+        taxonomyOwned: boolean;
+    }>;
+    listPlanningRevisionProjections(input: {
+        tenantId: string;
+        workspaceId: string;
+        domain: 'initiative' | 'workstream';
+        entityIds: string[];
+    }): WorkspaceSyncPlanningRevisionProjection[];
+    ensureInitiativeRevisionBaselines(input: {
+        tenantId: string;
+        workspaceId: string;
+        initiatives: WorkspaceSyncInitiativeBaseline[];
+        now: string;
+    }): {
+        highWatermark: string;
+        insertedEntities: number;
+        insertedJournalRows: number;
+    };
+    markTaskTaxonomyProjectionOwned(input: {
+        tenantId: string;
+        workspaceId: string;
+        taskIds: string[];
+        now: string;
+    }): void;
+    listTaskTaxonomyProjectionOwnership(input: {
+        tenantId: string;
+        workspaceId: string;
+        taskIds: string[];
+    }): Array<{
+        taskId: string;
+        activeOperation: boolean;
+        owned: boolean;
+    }>;
+    listOutboxTargets(identity: WorkspaceSyncOperationIdentity): WorkspaceSyncOutboxTarget[];
+    runTaskMetadataCoexistenceTransaction<T>(input: {
+        tenantId: string;
+        workspaceId: string;
+        direction: WorkspaceSyncTaskMetadataCoexistenceDirection;
+        taskIds: string[];
+        now: string;
+        apply: (ownership: WorkspaceSyncTaskMetadataOwnership[]) => T;
+    }): T;
+    runWorkspaceDomainCoexistenceTransaction<T>(input: {
+        tenantId: string;
+        workspaceId: string;
+        direction: WorkspaceSyncTaskMetadataCoexistenceDirection;
+        targets: WorkspaceSyncDomainCoexistenceTarget[];
+        now: string;
+        apply: () => T;
+    }): T;
+    requeueLegacyPlanningAttachmentAcknowledgements(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueSupersededTaskAttachmentReferenceMetadataConflicts(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueSupersededOriginDispatchAuthorizationFailures(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueSupersededTaskCreateChecklistAcknowledgements(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueInitialTaskCreateRouteMisses(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueSupersededTaskCommentReconciliationConflicts(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueTaskCommentRootAcknowledgementConflicts(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueBoundedTaskStatusRevisionConflicts(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueBoundedWorkstreamMetadataRevisionConflicts(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueBoundedInitiativeMetadataRevisionConflicts(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueTaskCommentProvenanceReconciliationConflicts(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    supersedeArchivedReadOnlyTaskRecoveryIntents(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+        isTaskArchived: (taskId: string) => boolean;
+    }): number;
+    requeueSupersededTaskStatusWorkflowAcknowledgements(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueTaskStatusAssigneeAcknowledgements(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    requeueTaskStatusWorkflowHistoryAcknowledgements(input: {
+        tenantId: string;
+        workspaceId: string;
+        now: string;
+    }): number;
+    claimOutbox(input: {
+        tenantId: string;
+        workspaceId: string;
+        leaseOwner?: string;
+        now: string;
+        leaseExpiresAt: string;
+        limit: number;
+        dispatchClasses?: readonly WorkspaceSyncOutboxDispatchClass[];
+    }): {
+        leaseOwner: string;
+        records: WorkspaceSyncOutboxRecord[];
+    };
+    releaseOutboxClaim(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        leaseOwner: string;
+        now: string;
+        nextAttemptAt: string;
+        errorCode?: string | null;
+        errorMessage?: string | null;
+        incrementInitialNotFoundAttemptCount?: boolean;
+    }): void;
+    blockOutboxClaim(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        leaseOwner: string;
+        now: string;
+        errorCode: string;
+        errorMessage: string;
+    }): void;
+    applyAuthoritativeAndAck<T>(input: {
+        identity: WorkspaceSyncOperationIdentity;
+        leaseOwner: string;
+        now: string;
+        response: unknown;
+        acceptedSequence: string | number;
+        authoritative?: {
+            domain: string;
+            entityId: string;
+            mutationKind: string;
+            entityRevision: string | number;
+            lifecycleRevision: string | number;
+            sequence: string | number;
+            canonicalFingerprint: string;
+            metadataOwned?: boolean;
+            reopenAssigneeOwned?: boolean;
+            allowAuthoritativeRevisionReset?: boolean;
+        } | Array<{
+            domain: string;
+            entityId: string;
+            mutationKind: string;
+            entityRevision: string | number;
+            lifecycleRevision: string | number;
+            sequence: string | number;
+            canonicalFingerprint: string;
+            metadataOwned?: boolean;
+            reopenAssigneeOwned?: boolean;
+            allowAuthoritativeRevisionReset?: boolean;
+        }>;
+        applyAuthoritative: () => T;
+    }): T;
+    private isTargetStateLifecycleConflict;
+    private isTaskLifecycleRecoveryIntentSatisfied;
+    private normalizeRecoveredWorkflowStepEvidence;
+    private prepareRecoveryPayload;
+    private parseFrozenRecoveryPayload;
+    private readEntityEventLegacyAdoptionRecoveryIntent;
+    private readTaskCreateRecoveryIntent;
+    private assertTaskCreateRecoveryIntentSatisfied;
+    private readTaskAttachmentLinksRecoveryIntent;
+    private isTaskAttachmentLinksRecoveryIntentSatisfied;
+    private readTaskCommentAppendRecoveryIntent;
+    private prepareTaskCommentAppendRecoveryPayload;
+    private assertTaskCommentAppendRecoveryEventOwned;
+    private isTaskCommentAppendRecoveryIntentSatisfied;
+    private prepareTaskRecoveryPayload;
+    private allocateSequenceRange;
+    private allocateOutboxEnqueueSequence;
+    private readOperationRow;
+    private assertMatchingOperation;
+    private mapOutboxRow;
+}
+export declare function runReservedWorkspaceSyncV3Operation<T>(input: {
+    store: WorkspaceSyncDurabilityStore;
+    identity: WorkspaceSyncOperationIdentity;
+    requestFingerprint: string;
+    now: string;
+    leaseExpiresAt: string;
+    leaseOwner?: string;
+    attempt: (reservation: {
+        leaseOwner: string;
+    }) => T;
+}): T | Extract<WorkspaceSyncOperationReservation, {
+    state: 'in_progress' | 'committed';
+}>;