@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/sync/v3/durableTaskHttpRootMutationRouter.js

@@ -0,0 +1,518 @@
+import { selectDurableTaskMetadataPatch } from '../../core/TaskDurableSyncMutationService.js';
+import { prepareTaskDeleteForDurableSync } from '../../core/TaskDurableDeleteMutationService.js';
+import { selectTaskCreateActivationInput } from './taskCreateActivation.js';
+import { resolveTaskAttachmentLinksMutationCapability } from './durableTaskAttachmentLinksMutationRouter.js';
+import { runDurableTaskCreate } from './taskCreateMutationService.js';
+import { runDurableTaskDelete } from './taskDeleteMutationService.js';
+import { runDurableTaskLifecycleMutation } from './taskLifecycleMutationService.js';
+import { runDurableTaskMetadataUpdate } from './taskMetadataMutationService.js';
+import { runDurableTaskStatusMutation } from './taskStatusMutationService.js';
+import { runDurableTaskRestore } from './taskRestoreMutationService.js';
+import { DurableOperationReplayIdentityConflictError, DurableOperationReplayInvalidResponseError, readDurableOperationReplay, } from './durableOperationReplay.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, WorkspaceSyncDurabilityStore, } from './syncDurabilityStore.js';
+const OPERATION_LEASE_MS = 30_000;
+const TASK_HTTP_CARRIER_FIELDS = new Set(['attachments', 'checklistItems', 'comments']);
+const TASK_HTTP_NON_MUTATION_FIELDS = new Set(['saveSource']);
+const TASK_HTTP_STATUS_FIELDS = new Set([
+    'status', 'completedAt', 'completed', 'inProgress', 'readyForReview', 'cancelled', 'canceledReason',
+]);
+function isEnabled(value) {
+    return /^(1|true|on|yes)$/i.test(String(value || '').trim());
+}
+function requiredText(value, label) {
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        throw new DurableTaskHttpRootMutationError(`${label} is required for durable cloud task mutations.`, 'WORKSPACE_SYNC_OPERATION_ID_REQUIRED', 400);
+    return normalized;
+}
+export class DurableTaskHttpRootMutationError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'DurableTaskHttpRootMutationError';
+    }
+}
+function rethrowDurableReplayError(error, invalidMessage) {
+    if (error instanceof DurableOperationReplayIdentityConflictError) {
+        throw new DurableTaskHttpRootMutationError('Operation identity was already used for a different durable task mutation.', 'WORKSPACE_SYNC_OPERATION_ID_CONFLICT', 409);
+    }
+    if (error instanceof DurableOperationReplayInvalidResponseError) {
+        throw new DurableTaskHttpRootMutationError(invalidMessage, 'WORKSPACE_SYNC_COMMITTED_RESPONSE_INVALID', 500);
+    }
+    throw error;
+}
+export function resolveTaskHttpRootMutationCapability(input) {
+    const env = input.env || process.env;
+    return input.runtimeMode === 'cloud'
+        && isEnabled(env.TASKFORCE_SYNC_V3_TASK_CLOUD_HTTP_ACTIVATION_ENABLED)
+        && isEnabled(env.TASKFORCE_SYNC_V3_TASKS_ENABLED);
+}
+export function createDurableTaskHttpRootMutationRouter(input) {
+    const enabled = resolveTaskHttpRootMutationCapability(input);
+    const attachmentLinksEnabled = resolveTaskAttachmentLinksMutationCapability({
+        runtimeMode: input.runtimeMode,
+        surface: 'http',
+        env: input.env,
+    });
+    const store = new WorkspaceSyncDurabilityStore(input.core.getDatabaseAdapter());
+    const now = input.now || (() => new Date());
+    const notificationMethods = new Set([
+        'notifyDurableTaskCreateCommitted',
+        'notifyDurableTaskMetadataCommitted',
+        'notifyDurableTaskLifecycleCommitted',
+        'notifyDurableTaskDeleteCommitted',
+    ]);
+    const serviceCore = input.deferPostCommitNotification
+        ? new Proxy(input.core, {
+            get(target, property) {
+                const value = Reflect.get(target, property, target);
+                if (notificationMethods.has(property) && typeof value === 'function') {
+                    return (...args) => input.deferPostCommitNotification?.(() => value.apply(target, args));
+                }
+                return typeof value === 'function' ? value.bind(target) : value;
+            },
+        })
+        : input.core;
+    const context = (requireRootOwnership = true) => {
+        if (requireRootOwnership && !enabled)
+            throw new DurableTaskHttpRootMutationError('Durable cloud task HTTP mutations are disabled.', 'WORKSPACE_SYNC_V3_TASK_CLOUD_HTTP_DISABLED', 409);
+        const acceptedAt = now();
+        return {
+            acceptedAt,
+            acceptedAtIso: acceptedAt.toISOString(),
+            operationId: requiredText(input.operationId, 'Operation id'),
+        };
+    };
+    const operationIdentity = (operationId) => ({
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        clientId: 'http-cloud',
+        operationId,
+    });
+    const taskBaseRevisions = (taskId, operationId, mutationKind) => {
+        const identity = operationIdentity(operationId);
+        const committedResponseJson = store.readCommittedOperationResponse(identity);
+        if (!committedResponseJson)
+            return store.readEntityRevisionCoordinates({
+                tenantId: input.tenantId,
+                workspaceId: input.workspaceId,
+                domain: 'task',
+                entityId: taskId,
+            });
+        try {
+            const replay = readDurableOperationReplay({
+                responseJson: committedResponseJson,
+                operationId,
+                domain: 'task',
+                entityId: taskId,
+                mutationKind,
+                revisionMode: 'both',
+            });
+            return {
+                entityRevision: replay.baseEntityRevision,
+                lifecycleRevision: replay.baseLifecycleRevision,
+            };
+        }
+        catch (error) {
+            rethrowDurableReplayError(error, 'Committed durable task HTTP response is invalid.');
+        }
+    };
+    const lifecycle = (taskIdInput, mutationKind, payload) => {
+        const taskId = requiredText(taskIdInput, 'Task id');
+        const operation = context();
+        const revisions = taskBaseRevisions(taskId, operation.operationId, mutationKind);
+        const result = runDurableTaskLifecycleMutation({
+            store,
+            core: serviceCore,
+            ...operationIdentity(operation.operationId),
+            taskId,
+            mutationKind,
+            payload,
+            baseEntityRevision: revisions.entityRevision,
+            baseLifecycleRevision: revisions.lifecycleRevision,
+            now: operation.acceptedAtIso,
+            leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
+            actorRef: input.actorRef,
+            onPostCommitError: input.onPostCommitError,
+        });
+        if (result.state === 'in_progress')
+            throw new DurableTaskHttpRootMutationError('The durable task mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
+        return result.response.authoritative.payload;
+    };
+    return {
+        enabled,
+        create(candidate) {
+            const source = candidate && typeof candidate === 'object' && !Array.isArray(candidate)
+                ? candidate
+                : null;
+            const taskId = String(source?.id || '').trim();
+            const selected = source
+                ? selectTaskCreateActivationInput(Object.fromEntries(Object.entries(source).filter(([key]) => key !== 'id')))
+                : null;
+            if (!selected || !taskId)
+                throw new DurableTaskHttpRootMutationError('Task create is not supported by the durable cloud HTTP contract.', 'TASK_CREATE_UNSUPPORTED_INPUT', 400);
+            const operation = context();
+            const result = runDurableTaskCreate({
+                store,
+                core: serviceCore,
+                tenantId: input.tenantId,
+                workspaceId: input.workspaceId,
+                clientId: 'http-cloud',
+                operationId: operation.operationId,
+                provisionalTaskId: taskId,
+                task: selected.task,
+                carriers: {
+                    attachments: attachmentLinksEnabled ? [] : selected.localTask.attachments || [],
+                    checklistItems: selected.localTask.checklistItems || [],
+                    comments: selected.localTask.comments || [],
+                },
+                attachmentLinks: attachmentLinksEnabled && selected.localTask.attachments?.length
+                    ? input.core.normalizeTaskAttachmentDescriptorsForDurableSync(selected.localTask.attachments, input.workspaceId)
+                    : [],
+                baseEntityRevision: 0,
+                baseLifecycleRevision: 0,
+                now: operation.acceptedAtIso,
+                leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
+                actorRef: input.actorRef,
+                onPostCommitError: input.onPostCommitError,
+            });
+            if (result.state === 'in_progress')
+                throw new DurableTaskHttpRootMutationError('The durable task mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
+            return result.response.authoritative.payload;
+        },
+        update(taskIdInput, candidate, saveSource, activityAction) {
+            const taskId = requiredText(taskIdInput, 'Task id');
+            if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+                throw new DurableTaskHttpRootMutationError('Task patch must be an object.', 'DURABLE_TASK_PATCH_INVALID', 400);
+            }
+            const source = candidate;
+            const hasStatus = Object.prototype.hasOwnProperty.call(source, 'status');
+            const unsupported = Object.keys(source).filter((key) => (!TASK_HTTP_CARRIER_FIELDS.has(key)
+                && !TASK_HTTP_NON_MUTATION_FIELDS.has(key)
+                && !(hasStatus && TASK_HTTP_STATUS_FIELDS.has(key))
+                && !Object.prototype.hasOwnProperty.call(selectDurableTaskMetadataPatch({ [key]: source[key] }), key)));
+            if (unsupported.length > 0)
+                throw new DurableTaskHttpRootMutationError(`Task patch contains fields not yet supported by the durable cloud HTTP contract: ${unsupported.sort().join(', ')}.`, 'DURABLE_TASK_HTTP_PATCH_UNSUPPORTED', 400);
+            const metadataPatch = selectDurableTaskMetadataPatch(source);
+            const assigneeProvided = Object.prototype.hasOwnProperty.call(source, 'assignee');
+            if (hasStatus)
+                delete metadataPatch.assignee;
+            const carrierPatch = Object.fromEntries(Object.entries(source).filter(([key]) => TASK_HTTP_CARRIER_FIELDS.has(key)));
+            if (hasStatus && Object.keys(carrierPatch).length > 0)
+                throw new DurableTaskHttpRootMutationError('Combined task status and carrier patches are not supported by the durable cloud HTTP contract.', 'DURABLE_TASK_HTTP_PATCH_UNSUPPORTED', 400);
+            if (hasStatus) {
+                const operation = context();
+                const revisions = taskBaseRevisions(taskId, operation.operationId, 'set-status');
+                const result = runDurableTaskStatusMutation({
+                    store,
+                    core: serviceCore,
+                    ...operationIdentity(operation.operationId),
+                    taskId,
+                    payload: {
+                        status: source.status,
+                        assigneeIntent: assigneeProvided
+                            ? { kind: 'set', value: source.assignee ?? null }
+                            : { kind: 'preserve' },
+                        canceledReason: source.status === 'cancelled' ? (source.canceledReason ?? null) : null,
+                        metadataPatch,
+                    },
+                    baseEntityRevision: revisions.entityRevision,
+                    baseLifecycleRevision: revisions.lifecycleRevision,
+                    now: operation.acceptedAtIso,
+                    leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
+                    actorRef: input.actorRef,
+                    onPostCommitError: input.onPostCommitError,
+                });
+                if (result.state === 'in_progress')
+                    throw new DurableTaskHttpRootMutationError('The durable task mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
+                return result.response.authoritative.payload;
+            }
+            if (Object.keys(metadataPatch).length > 0 || Object.keys(carrierPatch).length > 0) {
+                const operation = context();
+                const identity = {
+                    tenantId: input.tenantId,
+                    workspaceId: input.workspaceId,
+                    clientId: 'http-cloud',
+                    operationId: operation.operationId,
+                };
+                let baseEntityRevision;
+                let baseLifecycleRevision;
+                const committedResponseJson = store.readCommittedOperationResponse(identity);
+                if (committedResponseJson) {
+                    try {
+                        const replay = readDurableOperationReplay({
+                            responseJson: committedResponseJson,
+                            operationId: operation.operationId,
+                            domain: 'task',
+                            entityId: taskId,
+                            mutationKind: 'metadata-update',
+                            revisionMode: 'metadata',
+                            requirePayload: true,
+                        });
+                        baseEntityRevision = replay.baseEntityRevision;
+                        baseLifecycleRevision = replay.baseLifecycleRevision;
+                    }
+                    catch (error) {
+                        rethrowDurableReplayError(error, 'Committed durable task HTTP response is invalid.');
+                    }
+                }
+                else {
+                    const revisions = store.readEntityRevisionCoordinates({
+                        tenantId: input.tenantId,
+                        workspaceId: input.workspaceId,
+                        domain: 'task',
+                        entityId: taskId,
+                    });
+                    baseEntityRevision = revisions.entityRevision;
+                    baseLifecycleRevision = revisions.lifecycleRevision;
+                }
+                const result = runDurableTaskMetadataUpdate({
+                    store,
+                    core: serviceCore,
+                    ...identity,
+                    taskId,
+                    patch: metadataPatch,
+                    ...(Object.keys(carrierPatch).length > 0 ? { carriers: carrierPatch } : {}),
+                    baseEntityRevision,
+                    baseLifecycleRevision,
+                    now: operation.acceptedAtIso,
+                    leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
+                    actorRef: input.actorRef,
+                    saveSource,
+                    activityAction,
+                    onPostCommitError: input.onPostCommitError,
+                });
+                if (result.state === 'in_progress')
+                    throw new DurableTaskHttpRootMutationError('The durable task mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
+                return result.response.authoritative.payload;
+            }
+            const task = input.core.getTask(taskId, input.workspaceId);
+            if (!task)
+                throw new DurableTaskHttpRootMutationError('Task not found.', 'TASK_NOT_FOUND', 404);
+            return task;
+        },
+        runBatch(routeInput, request, apply, options) {
+            const route = requiredText(routeInput, 'Batch route');
+            const operation = context(!options?.allowIndependentNestedOwnership);
+            const identity = operationIdentity(operation.operationId);
+            const requestFingerprint = fingerprintWorkspaceSyncPayload({
+                contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+                identity,
+                operation: { domain: 'http-task-batch', route, request },
+            });
+            const reservation = store.reserveOperation({
+                identity,
+                requestFingerprint,
+                now: operation.acceptedAtIso,
+                leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
+            });
+            if (reservation.state === 'in_progress')
+                throw new DurableTaskHttpRootMutationError('The durable task batch mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
+            if (reservation.state === 'committed') {
+                let committed;
+                try {
+                    committed = JSON.parse(reservation.responseJson);
+                }
+                catch {
+                    throw new DurableTaskHttpRootMutationError('Committed durable task batch response is invalid.', 'WORKSPACE_SYNC_COMMITTED_RESPONSE_INVALID', 500);
+                }
+                if (committed.contractVersion !== WORKSPACE_SYNC_CONTRACT_VERSION
+                    || committed.operationId !== operation.operationId
+                    || committed.route !== route
+                    || !Object.prototype.hasOwnProperty.call(committed, 'result'))
+                    throw new DurableTaskHttpRootMutationError('Committed durable task batch response is invalid.', 'WORKSPACE_SYNC_COMMITTED_RESPONSE_INVALID', 500);
+                return committed.result;
+            }
+            const commit = (result) => store.commitReservedOperationResponse({
+                identity,
+                requestFingerprint,
+                leaseOwner: reservation.leaseOwner,
+                now: operation.acceptedAtIso,
+                response: {
+                    contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+                    operationId: operation.operationId,
+                    route,
+                    result,
+                },
+            });
+            if (options?.atomicRecovery) {
+                const notifications = [];
+                const result = input.core.getDatabaseAdapter().transaction(() => {
+                    const value = apply({
+                        runChild: (mutation) => input.core.getDatabaseAdapter().transaction(mutation)(),
+                        deferPostCommitNotification: (notify) => notifications.push(notify),
+                    });
+                    commit(value);
+                    return value;
+                })();
+                for (const notify of notifications) {
+                    try {
+                        notify();
+                    }
+                    catch (error) {
+                        try {
+                            input.onPostCommitError?.(error);
+                        }
+                        catch { /* committed batch remains successful */ }
+                    }
+                }
+                return result;
+            }
+            const result = apply({
+                runChild: (mutation) => mutation(),
+                deferPostCommitNotification: (notify) => notify(),
+            });
+            commit(result);
+            return result;
+        },
+        archive(taskId, cancellation, reason) {
+            return lifecycle(taskId, 'archive', { cancellation, reason });
+        },
+        unarchive(taskId) {
+            return lifecycle(taskId, 'unarchive', {});
+        },
+        restore(deletedRecordIdInput, restoreDestination = 'previous') {
+            const deletedRecordId = requiredText(deletedRecordIdInput, 'Deleted record id');
+            const operation = context();
+            const identity = operationIdentity(operation.operationId);
+            const committedResponseJson = store.readCommittedOperationResponse(identity);
+            let taskId;
+            let baseEntityRevision;
+            let baseLifecycleRevision;
+            if (committedResponseJson) {
+                try {
+                    const replay = readDurableOperationReplay({
+                        responseJson: committedResponseJson,
+                        operationId: operation.operationId,
+                        domain: 'task',
+                        mutationKind: 'metadata-update',
+                        revisionMode: 'both',
+                        requirePayload: true,
+                        predicate: (entry, response) => response.deletedRecordId === deletedRecordId
+                            && Boolean(entry.payload && typeof entry.payload === 'object'
+                                && !Array.isArray(entry.payload)
+                                && entry.payload.id === entry.entityId),
+                    });
+                    taskId = replay.authoritative.entityId;
+                    baseEntityRevision = replay.baseEntityRevision;
+                    baseLifecycleRevision = replay.baseLifecycleRevision;
+                }
+                catch (error) {
+                    rethrowDurableReplayError(error, 'Committed durable task restore response is invalid.');
+                }
+            }
+            else {
+                const deleted = input.core.getDeletedTask(deletedRecordId, input.workspaceId);
+                if (!deleted)
+                    throw new DurableTaskHttpRootMutationError('Deleted task not found.', 'DELETED_TASK_NOT_FOUND', 404);
+                taskId = deleted.taskId;
+                const revisions = store.readEntityRevisionCoordinates({
+                    tenantId: input.tenantId,
+                    workspaceId: input.workspaceId,
+                    domain: 'task',
+                    entityId: taskId,
+                });
+                baseEntityRevision = revisions.entityRevision;
+                baseLifecycleRevision = revisions.lifecycleRevision;
+            }
+            const result = runDurableTaskRestore({
+                store,
+                core: serviceCore,
+                ...identity,
+                deletedRecordId,
+                taskId,
+                baseEntityRevision,
+                baseLifecycleRevision,
+                now: operation.acceptedAtIso,
+                leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
+                actorRef: input.actorRef,
+                restoreDestination,
+                onPostCommitError: input.onPostCommitError,
+            });
+            if (result.state === 'in_progress')
+                throw new DurableTaskHttpRootMutationError('The durable task mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
+            return result.response.authoritative.payload;
+        },
+        delete(taskIdInput) {
+            const taskId = requiredText(taskIdInput, 'Task id');
+            const operation = context();
+            const identity = operationIdentity(operation.operationId);
+            const committedResponseJson = store.readCommittedOperationResponse(identity);
+            let baseEntityRevision;
+            let baseLifecycleRevision;
+            let relationshipBaseRevisions;
+            if (committedResponseJson) {
+                try {
+                    const replay = readDurableOperationReplay({
+                        responseJson: committedResponseJson,
+                        operationId: operation.operationId,
+                        domain: 'task',
+                        entityId: taskId,
+                        mutationKind: 'delete',
+                        revisionMode: 'both',
+                        authoritativeMode: 'multiple',
+                    });
+                    if (replay.authoritativeEntries.some((entry) => entry.mutationKind !== 'delete')) {
+                        throw new DurableOperationReplayIdentityConflictError();
+                    }
+                    baseEntityRevision = replay.baseEntityRevision;
+                    baseLifecycleRevision = replay.baseLifecycleRevision;
+                    relationshipBaseRevisions = replay.authoritativeEntries
+                        .filter((entry) => entry.domain === 'task-relationship')
+                        .map((entry) => ({
+                        entityId: entry.entityId,
+                        baseEntityRevision: (BigInt(entry.entityRevision) - 1n).toString(),
+                        baseLifecycleRevision: (BigInt(entry.lifecycleRevision) - 1n).toString(),
+                    }));
+                }
+                catch (error) {
+                    rethrowDurableReplayError(error, 'Committed durable task delete response is invalid.');
+                }
+            }
+            else {
+                const revisions = store.readEntityRevisionCoordinates({
+                    tenantId: input.tenantId, workspaceId: input.workspaceId, domain: 'task', entityId: taskId,
+                });
+                baseEntityRevision = revisions.entityRevision;
+                baseLifecycleRevision = revisions.lifecycleRevision;
+                relationshipBaseRevisions = prepareTaskDeleteForDurableSync({
+                    core: input.core, workspaceId: input.workspaceId, taskId,
+                }).relationships.map((relationship) => {
+                    const relationshipRevisions = store.readEntityRevisionCoordinates({
+                        tenantId: input.tenantId,
+                        workspaceId: input.workspaceId,
+                        domain: 'task-relationship',
+                        entityId: relationship.id,
+                    });
+                    return {
+                        entityId: relationship.id,
+                        baseEntityRevision: relationshipRevisions.entityRevision,
+                        baseLifecycleRevision: relationshipRevisions.lifecycleRevision,
+                    };
+                });
+            }
+            const result = runDurableTaskDelete({
+                store,
+                core: serviceCore,
+                ...identity,
+                taskId,
+                baseEntityRevision,
+                baseLifecycleRevision,
+                relationshipBaseRevisions,
+                now: operation.acceptedAtIso,
+                leaseExpiresAt: new Date(operation.acceptedAt.getTime() + OPERATION_LEASE_MS).toISOString(),
+                actorRef: input.actorRef,
+                onPostCommitError: input.onPostCommitError,
+            });
+            if (result.state === 'in_progress')
+                throw new DurableTaskHttpRootMutationError('The durable task mutation is already in progress.', 'WORKSPACE_SYNC_OPERATION_IN_PROGRESS', 409);
+            const deleted = input.core.getDeletedTask(taskId, input.workspaceId);
+            if (!deleted)
+                throw new DurableTaskHttpRootMutationError('Durable task delete committed without a Trash record.', 'TASK_DELETE_FAILED', 500);
+            return deleted;
+        },
+    };
+}

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

@@ -0,0 +1,63 @@
+import type { NormalizedWorkspaceTaxonomyState, WorkspaceTaxonomyState } from '../../shared/taxonomyState.js';
+import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
+import { type LocalTaxonomyOutboxCore } from './localTaxonomyOutboxService.js';
+import { type DurableTaxonomyServiceCore } from './taxonomyMutationService.js';
+import { type DurableTaxonomyCompositeCore } from './taxonomyCompositeMutationService.js';
+export type TaxonomyActivationSurface = 'http' | 'mcp';
+export declare function resolveTaxonomyActivationCapability(input: {
+    runtimeMode: 'local' | 'cloud';
+    surface: TaxonomyActivationSurface;
+    env?: NodeJS.ProcessEnv;
+}): {
+    taxonomyActivation: boolean;
+};
+export type DurableTaxonomyMutationRouterCore = DurableTaxonomyServiceCore & LocalTaxonomyOutboxCore & DurableTaxonomyCompositeCore & {
+    getDatabaseAdapter(): DatabaseAdapter;
+};
+export type DurableTaxonomyMutationRouterResult = {
+    state: 'pending' | 'committed';
+    route: 'local-outbox' | 'cloud-acceptance';
+    operationId: string;
+    taxonomyState: NormalizedWorkspaceTaxonomyState;
+    remappedTaskIds?: string[];
+};
+export declare class DurableTaxonomyMutationRouterDisabledError extends Error {
+    readonly code = "WORKSPACE_SYNC_V3_TAXONOMY_ACTIVATION_DISABLED";
+    constructor();
+}
+export declare class DurableTaxonomyMutationRouterInProgressError extends Error {
+    readonly retryAt: string;
+    readonly code = "WORKSPACE_SYNC_OPERATION_IN_PROGRESS";
+    readonly statusCode = 409;
+    constructor(retryAt: string);
+}
+export declare function createDurableTaxonomyMutationRouter(input: {
+    core: DurableTaxonomyMutationRouterCore;
+    runtimeMode: 'local' | 'cloud';
+    surface: TaxonomyActivationSurface;
+    tenantId: string;
+    workspaceId: string;
+    env?: NodeJS.ProcessEnv;
+    cloudClientId?: string;
+    createOperationId?: () => string;
+    now?: () => Date;
+    onPostCommitError?: (error: unknown) => void;
+}): {
+    enabled: boolean;
+    replaceState: (taxonomyState: WorkspaceTaxonomyState, options?: {
+        deferNotification?: boolean;
+    }, existingContext?: ReturnType<() => {
+        acceptedAt: Date;
+        acceptedAtIso: string;
+        operationId: string;
+        identity: {
+            tenantId: string;
+            workspaceId: string;
+            clientId: string;
+            operationId: string;
+        };
+    }>) => DurableTaxonomyMutationRouterResult;
+    mutateState(buildState: () => WorkspaceTaxonomyState, options?: {
+        remapIncompatibleTasks?: boolean;
+    }): DurableTaxonomyMutationRouterResult;
+};