@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/v3/localWorkflowRuntimeOutboxHandler.js

@@ -0,0 +1,113 @@
+import { EntityEventIdentityCollisionError } from '../../core/TaskActivityService.js';
+import { DurableTaskMetadataMutationError } from '../../core/TaskDurableSyncMutationService.js';
+import { TaskforceRuleError } from '../../core/Taskforce.js';
+import { WorkflowAssignmentSyncConflictError } from '../../storage/workflowStore.js';
+import { applyAuthoritativeWorkflowRuntimeAndAck, LocalAuthoritativeWorkflowRuntimeError, } from './localWorkflowRuntimeOutboxService.js';
+import { fingerprintWorkspaceSyncPayload, WorkspaceSyncIdempotencyConflictError, WorkspaceSyncRevisionConflictError, } from './syncDurabilityStore.js';
+import { validateWorkflowRuntimeMutationCommand, } from './workflowRuntimeSync.js';
+import { WorkflowAssignmentSyncError } from './workflowAssignmentSync.js';
+function parsePayload(record) {
+    let payload;
+    try {
+        payload = JSON.parse(record.payloadJson);
+    }
+    catch {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Local workflow payload is not valid JSON.');
+    }
+    if (fingerprintWorkspaceSyncPayload(payload) !== record.payloadFingerprint) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Local workflow payload fingerprint does not match persisted content.');
+    }
+    return validateWorkflowRuntimeMutationCommand(payload);
+}
+function buildEnvelope(record) {
+    const payload = parsePayload(record);
+    return {
+        contractVersion: 3,
+        workspaceId: record.workspaceId,
+        clientId: record.clientId,
+        operationId: record.operationId,
+        operation: {
+            domain: 'workflow-execution',
+            entityId: record.entityId,
+            mutationKind: payload.kind,
+            baseEntityRevision: record.baseEntityRevision,
+            baseLifecycleRevision: record.baseLifecycleRevision,
+            payload,
+        },
+    };
+}
+export function createLocalWorkflowRuntimeOutboxHandler(input) {
+    return {
+        key: 'workflow-execution/runtime',
+        supports: (record) => record.domain === 'workflow-execution'
+            && (record.mutationKind === 'transition' || record.mutationKind === 'complete-step'),
+        buildEnvelope,
+        resolveDispatchReadiness: (record) => {
+            const command = parsePayload(record);
+            const assignmentState = input.store.readWorkflowAssignmentDependencyState({
+                tenantId: record.tenantId,
+                workspaceId: record.workspaceId,
+                executionId: command.executionId,
+                beforeEnqueueSequence: record.enqueueSequence,
+            });
+            if (assignmentState) {
+                return assignmentState === 'blocked'
+                    ? {
+                        ready: false,
+                        retryable: false,
+                        errorCode: 'WORKSPACE_SYNC_DEPENDENCY_BLOCKED',
+                        errorMessage: 'The workflow assignment operation is blocked.',
+                    }
+                    : {
+                        ready: false,
+                        retryable: true,
+                        errorCode: 'WORKSPACE_SYNC_DEPENDENCY_PENDING',
+                        errorMessage: 'The workflow assignment operation has not been accepted yet.',
+                    };
+            }
+            const taskId = command.kind === 'complete-step' ? command.taskTarget.taskId : null;
+            if (!taskId)
+                return { ready: true };
+            const state = input.store.readTaskCreateDependencyState({
+                tenantId: record.tenantId,
+                workspaceId: record.workspaceId,
+                taskIds: [taskId],
+            });
+            if (!state)
+                return { ready: true };
+            return state === 'blocked'
+                ? {
+                    ready: false,
+                    retryable: false,
+                    errorCode: 'WORKSPACE_SYNC_DEPENDENCY_BLOCKED',
+                    errorMessage: 'The workflow task create operation is blocked.',
+                }
+                : {
+                    ready: false,
+                    retryable: true,
+                    errorCode: 'WORKSPACE_SYNC_DEPENDENCY_PENDING',
+                    errorMessage: 'The workflow task create operation has not been accepted yet.',
+                };
+        },
+        applyAuthoritative: (applyInput) => {
+            if (!applyInput.record) {
+                throw new LocalAuthoritativeWorkflowRuntimeError('Persisted workflow runtime operation context is missing.');
+            }
+            applyAuthoritativeWorkflowRuntimeAndAck({
+                store: input.store,
+                core: input.core,
+                ...applyInput,
+                record: applyInput.record,
+                onPostCommitError: input.onPostCommitError,
+            });
+        },
+        isPermanentApplyError: (error) => (error instanceof LocalAuthoritativeWorkflowRuntimeError
+            || error instanceof DurableTaskMetadataMutationError
+            || error instanceof TaskforceRuleError
+            || error instanceof WorkspaceSyncIdempotencyConflictError
+            || error instanceof WorkspaceSyncRevisionConflictError
+            || error instanceof EntityEventIdentityCollisionError
+            || error instanceof WorkflowAssignmentSyncError
+            || error instanceof WorkflowAssignmentSyncConflictError),
+    };
+}

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

@@ -0,0 +1,37 @@
+import type { EntityEvent } from '../../core/Taskforce.js';
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
+import { WorkflowStore } from '../../storage/workflowStore.js';
+import { WorkspaceSyncDurabilityStore, type WorkspaceSyncOperationIdentity, type WorkspaceSyncOutboxRecord } from './syncDurabilityStore.js';
+import { type DurableWorkflowRuntimeServiceCore } from './workflowRuntimeMutationService.js';
+export interface LocalWorkflowRuntimeOutboxCore extends DurableWorkflowRuntimeServiceCore {
+    getTenantId(): string;
+    getDatabaseAdapter(): DatabaseAdapter;
+    upsertEntityEventForSync(event: EntityEvent, options?: {
+        allowAuthoritativeReplacement?: boolean;
+    }): unknown;
+}
+export declare class LocalAuthoritativeWorkflowRuntimeError extends Error {
+    readonly code = "WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID";
+    constructor(message: string);
+}
+export declare function enqueueLocalWorkflowRuntimeMutation(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: LocalWorkflowRuntimeOutboxCore;
+    identity: WorkspaceSyncOperationIdentity;
+    command: unknown;
+    now: string;
+    onPostCommitError?: (error: unknown) => void;
+}): {
+    enqueued: boolean;
+    execution?: ReturnType<WorkflowStore['getProjectedExecution']>;
+};
+export declare function applyAuthoritativeWorkflowRuntimeAndAck(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: LocalWorkflowRuntimeOutboxCore;
+    identity: WorkspaceSyncOperationIdentity;
+    leaseOwner: string;
+    response: unknown;
+    record: WorkspaceSyncOutboxRecord;
+    now: string;
+    onPostCommitError?: (error: unknown) => void;
+}): void;

package/dist/sync/v3/localWorkflowRuntimeOutboxService.js

@@ -0,0 +1,330 @@
+import { WorkflowStore } from '../../storage/workflowStore.js';
+import { normalizeTaskSyncPayload } from '../taskSyncPayload.js';
+import { fingerprintWorkspaceSyncPayload, WorkspaceSyncIdempotencyConflictError, } from './syncDurabilityStore.js';
+import { applyPreparedWorkflowRuntimeMutation, prepareWorkflowRuntimeMutation, } from './workflowRuntimeMutationService.js';
+import { serializeWorkflowExecutionEventSyncPayload, validateWorkflowRuntimeAuthoritativeResult, validateWorkflowRuntimeMutationCommand, } from './workflowRuntimeSync.js';
+import { buildWorkflowRuntimeEventId, buildWorkflowRuntimeTaskActivityId, } from './workflowRuntimeOperationIdentity.js';
+import { serializeTaskActivityForSync } from './taskActivityJournal.js';
+export class LocalAuthoritativeWorkflowRuntimeError extends Error {
+    code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'LocalAuthoritativeWorkflowRuntimeError';
+    }
+}
+function parseRecordCommand(record) {
+    let payload;
+    try {
+        payload = JSON.parse(record.payloadJson);
+    }
+    catch {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Persisted workflow command is not valid JSON.');
+    }
+    if (fingerprintWorkspaceSyncPayload(payload) !== record.payloadFingerprint) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Persisted workflow command fingerprint does not match its content.');
+    }
+    return validateWorkflowRuntimeMutationCommand(payload);
+}
+export function enqueueLocalWorkflowRuntimeMutation(input) {
+    const command = validateWorkflowRuntimeMutationCommand(input.command);
+    const prior = input.store.readOutboxOperation(input.identity);
+    if (prior) {
+        if (prior.domain !== 'workflow-execution'
+            || prior.entityId !== command.executionId
+            || prior.mutationKind !== command.kind
+            || prior.payloadFingerprint !== fingerprintWorkspaceSyncPayload(command)) {
+            throw new WorkspaceSyncIdempotencyConflictError();
+        }
+        return { enqueued: false };
+    }
+    const workflowStore = new WorkflowStore(input.core.getDatabaseAdapter(), input.core.getTenantId());
+    const prepared = prepareWorkflowRuntimeMutation({
+        workflowStore,
+        workspaceId: input.identity.workspaceId,
+        clientId: input.identity.clientId,
+        operationId: input.identity.operationId,
+        command,
+    });
+    const additionalTargets = command.kind === 'complete-step'
+        && (prepared.willReassignTask || Boolean(command.evidenceCommentId))
+        ? [{
+                domain: 'task',
+                entityId: command.taskTarget.taskId,
+                mutationKind: 'metadata-update',
+                baseEntityRevision: command.taskTarget.baseEntityRevision,
+                baseLifecycleRevision: command.taskTarget.baseLifecycleRevision,
+                ownsTaskMetadata: true,
+                ownsTaskLifecycle: false,
+                ownsTaskAssignee: false,
+            }]
+        : [];
+    const result = input.store.enqueueLocalOperation({
+        identity: input.identity,
+        domain: 'workflow-execution',
+        entityId: command.executionId,
+        mutationKind: command.kind,
+        revisionSource: 'current',
+        queuedWorkflowRuntimeSuccessor: true,
+        additionalTargets,
+        payload: command,
+        now: input.now,
+        validateLockedState: () => {
+            const current = workflowStore.getExecutionStateSnapshot(input.identity.workspaceId, command.executionId);
+            if (!current || current.execution.status !== command.expectedStatus) {
+                throw new LocalAuthoritativeWorkflowRuntimeError('Workflow execution has advanced beyond the expected status.');
+            }
+            if (command.kind === 'complete-step'
+                && current.execution.currentStepId !== command.expectedStepId) {
+                throw new LocalAuthoritativeWorkflowRuntimeError('Workflow execution has advanced beyond the expected step.');
+            }
+        },
+        applyLocalMutation: () => applyPreparedWorkflowRuntimeMutation({
+            core: input.core,
+            workflowStore,
+            workspaceId: input.identity.workspaceId,
+            command,
+            prepared,
+            now: input.now,
+        }),
+    });
+    if (!result.enqueued)
+        return { enqueued: false };
+    const applied = result.mutationResult;
+    if (!applied)
+        throw new LocalAuthoritativeWorkflowRuntimeError('Local workflow mutation result is missing.');
+    const notify = (callback) => {
+        if (!callback)
+            return;
+        try {
+            callback();
+        }
+        catch (error) {
+            try {
+                input.onPostCommitError?.(error);
+            }
+            catch { /* capture remains committed */ }
+        }
+    };
+    notify(input.core.notifyDurableWorkflowRuntimeCommitted
+        ? () => input.core.notifyDurableWorkflowRuntimeCommitted?.(input.identity.workspaceId, command.executionId)
+        : undefined);
+    if (applied.task) {
+        notify(input.core.notifyDurableTaskMetadataCommitted
+            ? () => input.core.notifyDurableTaskMetadataCommitted?.(input.identity.workspaceId, applied.task.id)
+            : undefined);
+    }
+    return { enqueued: true, execution: applied.executionResult.execution };
+}
+function validateResponse(input) {
+    if (!input.response || typeof input.response !== 'object' || Array.isArray(input.response)) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow response must be an object.');
+    }
+    const response = input.response;
+    if (response.success !== true
+        || response.contractVersion !== 3
+        || response.workspaceId !== input.identity.workspaceId
+        || response.clientId !== input.identity.clientId
+        || response.operationId !== input.identity.operationId
+        || typeof response.acceptedSequence !== 'string'
+        || typeof response.operationHighWatermark !== 'string') {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow response identity is invalid.');
+    }
+    const command = parseRecordCommand(input.record);
+    if (input.record.domain !== 'workflow-execution'
+        || input.record.entityId !== command.executionId
+        || input.record.mutationKind !== command.kind) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Persisted workflow operation identity is invalid.');
+    }
+    const authoritative = validateWorkflowRuntimeAuthoritativeResult(response.authoritative);
+    if (authoritative.definition) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Workflow command acknowledgement cannot install a published definition.');
+    }
+    if (authoritative.execution.execution.id !== command.executionId
+        || authoritative.execution.execution.workspaceId !== input.identity.workspaceId
+        || authoritative.execution.execution.tenantId !== input.identity.tenantId) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow execution identity is invalid.');
+    }
+    const expectedEventIds = command.kind === 'transition'
+        ? [buildWorkflowRuntimeEventId({
+                workspaceId: input.identity.workspaceId,
+                clientId: input.identity.clientId,
+                operationId: input.identity.operationId,
+                suffix: 'transition',
+            })]
+        : [
+            buildWorkflowRuntimeEventId({
+                workspaceId: input.identity.workspaceId,
+                clientId: input.identity.clientId,
+                operationId: input.identity.operationId,
+                suffix: 'step-completed',
+            }),
+            buildWorkflowRuntimeEventId({
+                workspaceId: input.identity.workspaceId,
+                clientId: input.identity.clientId,
+                operationId: input.identity.operationId,
+                suffix: authoritative.task ? 'step-started' : 'execution-completed',
+            }),
+        ];
+    if (authoritative.acceptedEventIds.length !== expectedEventIds.length
+        || authoritative.acceptedEventIds.some((eventId, index) => eventId !== expectedEventIds[index])) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow event identity is invalid.');
+    }
+    if (authoritative.task) {
+        const expectedActivityId = buildWorkflowRuntimeTaskActivityId({
+            workspaceId: input.identity.workspaceId,
+            clientId: input.identity.clientId,
+            operationId: input.identity.operationId,
+            taskId: authoritative.task.payload.id,
+        });
+        if (authoritative.task.activity.id !== expectedActivityId) {
+            throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow task activity identity is invalid.');
+        }
+    }
+    const rootRevision = authoritative.revisions.find((revision) => revision.projection === 'workflow-execution/root-v1');
+    if (rootRevision?.sequence !== response.acceptedSequence
+        || authoritative.revisions.at(-1)?.sequence !== response.operationHighWatermark) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow response sequence is invalid.');
+    }
+    return { ...response, authoritative };
+}
+function assignmentWithAuthoritativeRuntime(input) {
+    return {
+        ...input.local,
+        execution: input.response.authoritative.execution.execution,
+        events: input.response.authoritative.events.map((entry) => entry.event),
+    };
+}
+export function applyAuthoritativeWorkflowRuntimeAndAck(input) {
+    const response = validateResponse(input);
+    const command = parseRecordCommand(input.record);
+    const authoritative = response.authoritative;
+    const workflowStore = new WorkflowStore(input.core.getDatabaseAdapter(), input.core.getTenantId());
+    const localAssignment = workflowStore.getAssignmentForExecutionSync(input.identity.workspaceId, command.executionId);
+    if (!localAssignment) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Local workflow assignment is missing.');
+    }
+    const localEvents = new Map(localAssignment.events.map((event) => [event.id, event]));
+    const authoritativeEvents = new Map(authoritative.events.map((entry) => [entry.event.id, entry]));
+    for (const eventId of authoritative.acceptedEventIds) {
+        const localEvent = localEvents.get(eventId);
+        const authoritativeEvent = authoritativeEvents.get(eventId);
+        if (!localEvent
+            || !authoritativeEvent
+            || fingerprintWorkspaceSyncPayload(serializeWorkflowExecutionEventSyncPayload(localEvent)) !== fingerprintWorkspaceSyncPayload(authoritativeEvent)) {
+            throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow event does not match the captured command.');
+        }
+    }
+    const expectedTaskActivityId = buildWorkflowRuntimeTaskActivityId({
+        workspaceId: input.identity.workspaceId,
+        clientId: input.identity.clientId,
+        operationId: input.identity.operationId,
+        taskId: localAssignment.execution.taskId,
+    });
+    const localTaskActivity = input.core.getTaskEventForSync({
+        workspaceId: input.identity.workspaceId,
+        taskId: localAssignment.execution.taskId,
+        eventId: expectedTaskActivityId,
+    });
+    if (Boolean(authoritative.task) !== Boolean(localTaskActivity)) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow task result does not match the captured command.');
+    }
+    if (authoritative.task
+        && localTaskActivity
+        && fingerprintWorkspaceSyncPayload(authoritative.task.activity)
+            !== fingerprintWorkspaceSyncPayload(serializeTaskActivityForSync(localTaskActivity))) {
+        throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow task activity does not match the captured command.');
+    }
+    const revisionDomain = (projection) => {
+        if (projection === 'workflow-execution/root-v1')
+            return 'workflow-execution';
+        if (projection === 'workflow-execution-event/full-v1')
+            return 'workflow-execution-event';
+        if (projection === 'task/root-v1')
+            return 'task';
+        if (projection === 'entity-event/full-v1')
+            return 'entity-event';
+        return 'workflow-published-definition';
+    };
+    const revisionMutationKind = (projection) => {
+        if (projection === 'workflow-execution/root-v1')
+            return command.kind;
+        if (projection === 'task/root-v1')
+            return 'metadata-update';
+        if (projection === 'workflow-published-definition/full-v2')
+            return 'publish';
+        return 'append';
+    };
+    let taskChanged = false;
+    input.store.applyAuthoritativeAndAck({
+        identity: input.identity,
+        leaseOwner: input.leaseOwner,
+        now: input.now,
+        response,
+        acceptedSequence: response.operationHighWatermark,
+        authoritative: authoritative.revisions.map((revision) => ({
+            domain: revisionDomain(revision.projection),
+            entityId: revision.entityId,
+            mutationKind: revisionMutationKind(revision.projection),
+            entityRevision: revision.entityRevision,
+            lifecycleRevision: revision.lifecycleRevision,
+            sequence: revision.sequence,
+            canonicalFingerprint: revision.canonicalFingerprint,
+            metadataOwned: revision.projection === 'task/root-v1',
+        })),
+        applyAuthoritative: () => {
+            workflowStore.installAssignmentForSync(input.identity.workspaceId, assignmentWithAuthoritativeRuntime({ local: localAssignment, response }), {
+                authority: 'cloud-execution',
+                expectedTaskId: authoritative.execution.execution.taskId,
+            });
+            if (authoritative.task) {
+                const task = normalizeTaskSyncPayload(authoritative.task.payload);
+                if (!task) {
+                    throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow task payload is invalid.');
+                }
+                const successors = input.store.listActiveOutboxSuccessors(input.identity);
+                const hasTaskSuccessor = successors.some((successor) => (input.store.listOutboxTargets({
+                    tenantId: successor.tenantId,
+                    workspaceId: successor.workspaceId,
+                    clientId: successor.clientId,
+                    operationId: successor.operationId,
+                }).some((target) => target.domain === 'task' && target.entityId === task.id)));
+                if (!hasTaskSuccessor) {
+                    const updated = input.core.updateTask(task.id, { assignee: task.assignee }, input.identity.workspaceId, {
+                        persistBackup: false,
+                        emitRealtime: false,
+                        skipTaskEvents: true,
+                        syncUpdatedAt: task.updatedAt,
+                        actorRef: 'system',
+                        allowV3OwnedMetadataWrite: true,
+                    });
+                    if (!updated) {
+                        throw new LocalAuthoritativeWorkflowRuntimeError('Authoritative workflow task is missing.');
+                    }
+                    taskChanged = true;
+                }
+                input.core.upsertEntityEventForSync(authoritative.task.activity, { allowAuthoritativeReplacement: true });
+            }
+        },
+    });
+    const notify = (callback) => {
+        if (!callback)
+            return;
+        try {
+            callback();
+        }
+        catch (error) {
+            try {
+                input.onPostCommitError?.(error);
+            }
+            catch { /* acknowledgement remains committed */ }
+        }
+    };
+    notify(input.core.notifyDurableWorkflowRuntimeCommitted
+        ? () => input.core.notifyDurableWorkflowRuntimeCommitted?.(input.identity.workspaceId, command.executionId)
+        : undefined);
+    if (taskChanged && authoritative.task) {
+        notify(input.core.notifyDurableTaskMetadataCommitted
+            ? () => input.core.notifyDurableTaskMetadataCommitted?.(input.identity.workspaceId, authoritative.task.payload.id)
+            : undefined);
+    }
+}

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

@@ -0,0 +1,63 @@
+import type { LocalSyncCoordinatorStore } from '../coordinator/localSyncCoordinatorStore.js';
+import { LocalSyncDispatchTracker } from '../coordinator/localSyncDispatchTracker.js';
+import type { LocalSyncExecutionPermitStore } from '../coordinator/localSyncExecutionPermitStore.js';
+import { type WorkspaceSyncTransportGateway } from '../coordinator/workspaceSyncTransportGateway.js';
+import { dispatchLocalOutboxBatch } from './localOutboxDispatcher.js';
+import { type LocalOutboxDispatchCore } from './localOutboxDispatchRuntime.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+import { type WorkspaceSyncTransferEvidence } from '../engine/workspaceSyncTransferEvidence.js';
+type ServerOutboxPermitStore = Pick<LocalSyncExecutionPermitStore, 'issueServer' | 'read' | 'completeAcceptedV3Dispatch' | 'abandonPermit'>;
+type ServerOutboxTransportGateway = Pick<WorkspaceSyncTransportGateway, 'executeServer'>;
+type ServerOutboxCoordinatorStore = Pick<LocalSyncCoordinatorStore, 'readOrCreateState'>;
+export declare class LocalWorkspaceSyncServerOutboxDispatcherError extends Error {
+    readonly code: 'SYNC_COORDINATOR_DISPATCH_INTAKE_CLOSED' | 'SYNC_COORDINATOR_STALE_GENERATION' | 'SYNC_COORDINATOR_INACTIVE_WORKSPACE' | 'SYNC_COORDINATOR_PERMITS_DISABLED';
+    constructor(message: string, code: 'SYNC_COORDINATOR_DISPATCH_INTAKE_CLOSED' | 'SYNC_COORDINATOR_STALE_GENERATION' | 'SYNC_COORDINATOR_INACTIVE_WORKSPACE' | 'SYNC_COORDINATOR_PERMITS_DISABLED');
+}
+export interface LocalWorkspaceSyncServerOutboxDispatcherOptions {
+    workspaceId: string;
+    coordinatorGeneration: number;
+    serverInstanceId: string;
+    core: LocalOutboxDispatchCore;
+    coordinatorStore: ServerOutboxCoordinatorStore;
+    permitStore: ServerOutboxPermitStore;
+    transportGateway: ServerOutboxTransportGateway;
+    dispatchTracker?: LocalSyncDispatchTracker;
+    durabilityStore?: WorkspaceSyncDurabilityStore;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    permitDeadlineMs?: number;
+    recordCommittedAuthoritativeApply?: () => void;
+    recordTransferEvidence?: (evidence: WorkspaceSyncTransferEvidence) => void;
+}
+/**
+ * Dark server-owned durable-v3 dispatcher.
+ *
+ * Production startup composes this behind the dark server-ownership gate. Its
+ * intake and tracker boundaries are intentionally explicit so ownership
+ * transfer can stop new claims and drain every claim through authoritative
+ * local apply.
+ */
+export declare class LocalWorkspaceSyncServerOutboxDispatcher {
+    private readonly options;
+    private readonly tracker;
+    private readonly store;
+    private readonly now;
+    private accepting;
+    constructor(options: LocalWorkspaceSyncServerOutboxDispatcherOptions);
+    get intakeOpen(): boolean;
+    get activeCount(): number;
+    closeIntake(): void;
+    drain(graceMs: number): Promise<void>;
+    dispatchOnce(options?: {
+        beforeTransport?: () => void;
+    }): Promise<Awaited<ReturnType<typeof dispatchLocalOutboxBatch>>>;
+    dispatchMigrationOnce(options?: {
+        beforeTransport?: () => void;
+    }): Promise<Awaited<ReturnType<typeof dispatchLocalOutboxBatch>>>;
+    private dispatchPreparedOnce;
+    private assertIntakeOpen;
+    private assertCurrentServerOwner;
+    private executeEnvelope;
+    private abandon;
+}
+export {};