@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/sync/v3/localTaskCommentOutboxService.js

@@ -0,0 +1,391 @@
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { buildTaskCommentActivityEventId } from './taskCommentActivityIdentity.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { serializeTaskActivityForSync } from './taskActivityJournal.js';
+import { fingerprintWorkspaceSyncPayload, } from './syncDurabilityStore.js';
+import { mergeWorkspaceSyncV3TaskCommentsPayload, serializeWorkspaceSyncV3TaskCommentsPayload, taskCommentBodiesMatchIgnoringProvenance, } from './workspaceSyncV3NestedTaskCodecs.js';
+import { withOriginActorPayload } from './workspaceSyncV3OriginActor.js';
+import { validateWorkspaceSyncV3TaskCommentReconcileProvenance, } from './taskCommentReconcileProvenance.js';
+export class LocalAuthoritativeTaskCommentError extends Error {
+    code = 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'LocalAuthoritativeTaskCommentError';
+    }
+}
+function canonicalComment(comment) {
+    const comments = serializeWorkspaceSyncV3TaskCommentsPayload({ taskId: '__validation__', comments: [comment] }).comments;
+    if (comments.length !== 1)
+        throw new LocalAuthoritativeTaskCommentError('Task comment is invalid.');
+    return comments[0];
+}
+function mergeComments(taskId, left, right) {
+    const byId = new Map();
+    for (const candidate of [...left, ...right]) {
+        const comment = canonicalComment(candidate);
+        const current = byId.get(comment.id);
+        if (current && canonicalWorkspaceSyncJson(current) !== canonicalWorkspaceSyncJson(comment)) {
+            throw new LocalAuthoritativeTaskCommentError(`Task comment identity conflict: ${comment.id}.`);
+        }
+        byId.set(comment.id, comment);
+    }
+    return serializeWorkspaceSyncV3TaskCommentsPayload({ taskId, comments: [...byId.values()] });
+}
+function canonicalTimestamp(value, label) {
+    const text = String(value || '');
+    const parsed = Date.parse(text);
+    if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== text) {
+        throw new LocalAuthoritativeTaskCommentError(`${label} is invalid.`);
+    }
+    return text;
+}
+export function enqueueLocalTaskCommentMutation(input) {
+    const comment = canonicalComment(input.comment);
+    const activityEventId = buildTaskCommentActivityEventId({
+        workspaceId: input.identity.workspaceId,
+        clientId: input.identity.clientId,
+        operationId: input.identity.operationId,
+        taskId: input.taskId,
+        commentId: comment.id,
+    });
+    const rootRevision = input.store.readEntityRevisionCoordinates({
+        tenantId: input.identity.tenantId,
+        workspaceId: input.identity.workspaceId,
+        domain: 'task',
+        entityId: input.taskId,
+    });
+    const result = input.store.enqueueLocalOperation({
+        identity: input.identity,
+        domain: 'task-comments',
+        entityId: input.taskId,
+        mutationKind: 'append',
+        revisionSource: 'current',
+        payload: withOriginActorPayload({ comment }, input.actorRef),
+        additionalTargets: [{
+                domain: 'task', entityId: input.taskId, mutationKind: 'metadata-update',
+                baseEntityRevision: rootRevision.entityRevision,
+                baseLifecycleRevision: rootRevision.lifecycleRevision,
+                ownsTaskMetadata: true,
+            }],
+        queuedTaskSuccessor: true,
+        ...(input.requireV3CombinedOwnership ? { requireV3PlanningOwnership: 'combined' } : {}),
+        now: input.now,
+        applyLocalMutation: () => {
+            const existing = input.core.getTask(input.taskId, input.identity.workspaceId);
+            if (!existing)
+                throw new LocalAuthoritativeTaskCommentError('Task not found.');
+            if (existing.isArchived)
+                throw new LocalAuthoritativeTaskCommentError('Archived tasks are read-only.');
+            if ((existing.comments || []).some((candidate) => candidate.id === comment.id)) {
+                throw new LocalAuthoritativeTaskCommentError(`Task comment identity conflict: ${comment.id}.`);
+            }
+            const merged = mergeComments(input.taskId, existing.comments || [], [comment]);
+            const currentMs = Date.parse(String(existing.updatedAt || existing.createdAt));
+            const requestedMs = Date.parse(input.now);
+            const updatedAt = Number.isFinite(currentMs) && currentMs >= requestedMs
+                ? new Date(currentMs + 1).toISOString()
+                : input.now;
+            const task = input.core.updateTask(input.taskId, { comments: merged.comments }, input.identity.workspaceId, {
+                persistBackup: false, emitRealtime: false, skipTaskEvents: true,
+                syncUpdatedAt: updatedAt, allowV3OwnedMetadataWrite: true,
+            });
+            if (!task)
+                throw new LocalAuthoritativeTaskCommentError('Task not found.');
+            input.core.addTaskCommentEventForDurableSync({
+                taskId: task.id, workspaceId: input.identity.workspaceId, actor: input.actorRef,
+                eventId: activityEventId, createdAt: String(task.updatedAt || input.now), comment,
+            });
+            return task;
+        },
+    });
+    if (!result.enqueued)
+        return { enqueued: false };
+    try {
+        input.core.notifyDurableTaskMetadataCommitted(input.identity.workspaceId, input.taskId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* local mutation and outbox remain committed */ }
+    }
+    return { enqueued: true, task: result.mutationResult };
+}
+export function enqueueLocalTaskCommentReconciliation(input) {
+    const requested = serializeWorkspaceSyncV3TaskCommentsPayload({
+        taskId: input.taskId,
+        comments: input.comments,
+    });
+    const provenance = validateWorkspaceSyncV3TaskCommentReconcileProvenance(input.provenance || []);
+    const result = input.store.enqueueLocalOperation({
+        identity: input.identity,
+        domain: 'task-comments',
+        entityId: input.taskId,
+        mutationKind: 'reconcile',
+        revisionSource: 'current',
+        payload: { comments: requested.comments, provenance },
+        queuedTaskSuccessor: true,
+        now: input.now,
+        applyLocalMutation: () => {
+            const existing = input.core.getTask(input.taskId, input.identity.workspaceId);
+            if (!existing)
+                throw new LocalAuthoritativeTaskCommentError('Task not found.');
+            const installed = new Map((existing.comments || []).map((comment) => [
+                comment.id,
+                canonicalComment(comment),
+            ]));
+            for (const comment of requested.comments) {
+                const candidate = installed.get(comment.id);
+                if (!candidate || canonicalWorkspaceSyncJson(candidate) !== canonicalWorkspaceSyncJson(comment)) {
+                    throw new LocalAuthoritativeTaskCommentError(`Task comment reconciliation source changed: ${comment.id}.`);
+                }
+            }
+            return existing;
+        },
+    });
+    if (!result.enqueued)
+        return { enqueued: false };
+    try {
+        input.core.notifyDurableTaskMetadataCommitted(input.identity.workspaceId, input.taskId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* outbox capture remains committed */ }
+    }
+    return { enqueued: true, task: result.mutationResult };
+}
+function requireRevision(value, label) {
+    const normalized = String(value ?? '');
+    if (!/^(0|[1-9]\d*)$/.test(normalized))
+        throw new LocalAuthoritativeTaskCommentError(`${label} is invalid.`);
+    return normalized;
+}
+export function applyAuthoritativeTaskCommentAndAck(input) {
+    if (!input.response || typeof input.response !== 'object' || Array.isArray(input.response)) {
+        throw new LocalAuthoritativeTaskCommentError('Authoritative task comment response must be an object.');
+    }
+    const response = input.response;
+    const root = response.authoritative?.root;
+    const comments = response.authoritative?.comments;
+    const activity = response.activity;
+    if (response.success !== true || response.contractVersion !== 3
+        || response.workspaceId !== input.identity.workspaceId
+        || response.clientId !== input.identity.clientId || response.operationId !== input.identity.operationId
+        || !root || !comments || !activity
+        || root.domain !== 'task' || root.mutationKind !== 'metadata-update'
+        || comments.domain !== 'task-comments' || comments.mutationKind !== 'append'
+        || root.entityId !== comments.entityId || root.payload.id !== root.entityId
+        || comments.payload.taskId !== comments.entityId
+        || activity.entityType !== 'task' || activity.entityId !== root.entityId || activity.taskId !== root.entityId
+        || activity.action !== 'task-comment-added') {
+        throw new LocalAuthoritativeTaskCommentError('Authoritative task comment response identity is invalid.');
+    }
+    const rootSequence = requireRevision(root.sequence, 'Authoritative root sequence');
+    const commentSequence = requireRevision(comments.sequence, 'Authoritative comment sequence');
+    const activitySequence = requireRevision(response.activityRevision?.sequence, 'Authoritative activity sequence');
+    const operationHighWatermark = requireRevision(response.operationHighWatermark, 'Authoritative operation high watermark');
+    if (requireRevision(response.acceptedSequence, 'Authoritative accepted sequence') !== rootSequence
+        || BigInt(commentSequence) !== BigInt(rootSequence) + 1n
+        || BigInt(activitySequence) !== BigInt(commentSequence) + 1n
+        || activitySequence !== operationHighWatermark
+        || response.activityRevision.domain !== 'entity-event'
+        || response.activityRevision.entityId !== activity.id
+        || requireRevision(response.activityRevision.entityRevision, 'Authoritative activity entity revision') !== '1'
+        || requireRevision(response.activityRevision.lifecycleRevision, 'Authoritative activity lifecycle revision') !== '0') {
+        throw new LocalAuthoritativeTaskCommentError('Authoritative task comment operation ordering is invalid.');
+    }
+    const rootPayload = serializeTaskForSync(root.payload);
+    const commentsPayload = serializeWorkspaceSyncV3TaskCommentsPayload({
+        taskId: comments.entityId, comments: comments.payload.comments,
+    });
+    const activityPayload = serializeTaskActivityForSync(activity);
+    const appendedCommentId = String(activity.details?.commentId || '');
+    const appendedComment = commentsPayload.comments.find((entry) => entry.id === appendedCommentId);
+    const expectedActivityId = appendedComment ? buildTaskCommentActivityEventId({
+        workspaceId: input.identity.workspaceId,
+        clientId: input.identity.clientId,
+        operationId: input.identity.operationId,
+        taskId: root.entityId,
+        commentId: appendedComment.id,
+    }) : '';
+    const activityDetails = activity.details;
+    if (!appendedComment
+        || activity.id !== expectedActivityId
+        || activity.workspaceId !== input.identity.workspaceId
+        || !String(activity.actor || '').trim()
+        || !['human', 'ai', 'system'].includes(activity.actorType)
+        || canonicalTimestamp(activity.createdAt, 'Authoritative task comment activity timestamp')
+            !== canonicalTimestamp(rootPayload.updatedAt, 'Authoritative task root timestamp')
+        || !activityDetails
+        || Object.keys(activityDetails).sort().join(',') !== 'commentId,preview,submittedAuthor'
+        || activityDetails.submittedAuthor !== appendedComment.submittedAuthor
+        || activityDetails.preview !== appendedComment.text.slice(0, 160)
+        || fingerprintWorkspaceSyncPayload(commentsPayload) !== fingerprintWorkspaceSyncPayload(serializeWorkspaceSyncV3TaskCommentsPayload({ taskId: root.entityId, comments: rootPayload.comments || [] }))) {
+        throw new LocalAuthoritativeTaskCommentError('Authoritative task comment activity or aggregate is invalid.');
+    }
+    const task = input.store.applyAuthoritativeAndAck({
+        identity: input.identity,
+        leaseOwner: input.leaseOwner,
+        now: input.now,
+        response,
+        acceptedSequence: operationHighWatermark,
+        // A comment append owns the comment aggregate and its activity event.
+        // The response also carries the task-root journal row because the cloud
+        // advances updatedAt, but acknowledging the append must not reinstall an
+        // older root over unrelated metadata accepted after this operation.
+        // The ordinary feed applies that independently versioned root row.
+        authoritative: [{
+                domain: 'task-comments', entityId: comments.entityId, mutationKind: 'append',
+                entityRevision: requireRevision(comments.entityRevision, 'Authoritative comment entity revision'),
+                lifecycleRevision: requireRevision(comments.lifecycleRevision, 'Authoritative comment lifecycle revision'),
+                sequence: commentSequence, canonicalFingerprint: fingerprintWorkspaceSyncPayload(commentsPayload),
+            }, {
+                domain: 'entity-event', entityId: activity.id, mutationKind: 'append',
+                entityRevision: requireRevision(response.activityRevision.entityRevision, 'Authoritative activity entity revision'),
+                lifecycleRevision: requireRevision(response.activityRevision.lifecycleRevision, 'Authoritative activity lifecycle revision'),
+                sequence: activitySequence, canonicalFingerprint: fingerprintWorkspaceSyncPayload(activityPayload),
+            }],
+        applyAuthoritative: () => {
+            const existing = input.core.getTask(root.entityId, input.identity.workspaceId);
+            if (!existing)
+                throw new LocalAuthoritativeTaskCommentError('Authoritative task root does not exist locally.');
+            if (input.store.hasActiveOutboxSuccessor(input.identity)) {
+                input.core.upsertEntityEventForSync(activity, { allowAuthoritativeReplacement: true });
+                return existing;
+            }
+            const updated = input.core.updateTask(root.entityId, { comments: commentsPayload.comments }, input.identity.workspaceId, {
+                persistBackup: false, emitRealtime: false, skipTaskEvents: true,
+                syncUpdatedAt: canonicalTimestamp(existing.updatedAt, 'Installed task root timestamp'),
+                allowV3OwnedMetadataWrite: true,
+            });
+            if (!updated)
+                throw new LocalAuthoritativeTaskCommentError('Authoritative task root disappeared locally.');
+            input.core.upsertEntityEventForSync(activity, { allowAuthoritativeReplacement: true });
+            const installedComments = serializeWorkspaceSyncV3TaskCommentsPayload({
+                taskId: updated.id, comments: updated.comments || [],
+            });
+            if (canonicalWorkspaceSyncJson(installedComments) !== canonicalWorkspaceSyncJson(commentsPayload)) {
+                throw new LocalAuthoritativeTaskCommentError('Installed task comment state does not match authority.');
+            }
+            return updated;
+        },
+    });
+    try {
+        input.core.notifyDurableTaskMetadataCommitted(input.identity.workspaceId, root.entityId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* authoritative state and ack remain committed */ }
+    }
+    return task;
+}
+export function applyAuthoritativeTaskCommentReconciliationAndAck(input) {
+    if (!input.response || typeof input.response !== 'object' || Array.isArray(input.response)) {
+        throw new LocalAuthoritativeTaskCommentError('Authoritative task comment reconciliation response must be an object.');
+    }
+    const response = input.response;
+    const comments = response.authoritative?.comments;
+    if (response.success !== true
+        || response.contractVersion !== 3
+        || response.workspaceId !== input.identity.workspaceId
+        || response.clientId !== input.identity.clientId
+        || response.operationId !== input.identity.operationId
+        || !comments
+        || !Array.isArray(response.verifiedContentActorIds)
+        || response.verifiedContentActorIds.some((actor) => !String(actor || '').trim())
+        || comments.domain !== 'task-comments'
+        || comments.mutationKind !== 'reconcile'
+        || comments.payload.taskId !== comments.entityId) {
+        throw new LocalAuthoritativeTaskCommentError('Authoritative task comment reconciliation response identity is invalid.');
+    }
+    const sequence = requireRevision(comments.sequence, 'Authoritative comment reconciliation sequence');
+    if (requireRevision(response.acceptedSequence, 'Authoritative accepted sequence') !== sequence
+        || requireRevision(response.operationHighWatermark, 'Authoritative operation high watermark') !== sequence
+        || requireRevision(comments.lifecycleRevision, 'Authoritative comment lifecycle revision') !== '0') {
+        throw new LocalAuthoritativeTaskCommentError('Authoritative task comment reconciliation ordering is invalid.');
+    }
+    const authoritative = serializeWorkspaceSyncV3TaskCommentsPayload({
+        taskId: comments.entityId,
+        comments: comments.payload.comments,
+    });
+    const task = input.store.applyAuthoritativeAndAck({
+        identity: input.identity,
+        leaseOwner: input.leaseOwner,
+        now: input.now,
+        response,
+        acceptedSequence: sequence,
+        authoritative: {
+            domain: 'task-comments',
+            entityId: comments.entityId,
+            mutationKind: 'reconcile',
+            entityRevision: requireRevision(comments.entityRevision, 'Authoritative comment reconciliation entity revision'),
+            lifecycleRevision: '0',
+            sequence,
+            canonicalFingerprint: fingerprintWorkspaceSyncPayload(authoritative),
+            // Reconciliation returns the complete stable-ID union from authority.
+            // Its purpose is to repair drift, including stale local coordinates.
+            allowAuthoritativeRevisionReset: true,
+        },
+        applyAuthoritative: () => {
+            const existing = input.core.getTask(comments.entityId, input.identity.workspaceId);
+            if (!existing) {
+                throw new LocalAuthoritativeTaskCommentError('Authoritative task comment reconciliation task does not exist locally.');
+            }
+            let installedPayload = authoritative;
+            if (input.store.hasActiveOutboxSuccessor(input.identity)) {
+                try {
+                    const authoritativeById = new Map(authoritative.comments.map((comment) => [comment.id, comment]));
+                    const localOnlySuccessors = (existing.comments || []).filter((comment) => {
+                        const accepted = authoritativeById.get(comment.id);
+                        if (!accepted)
+                            return true;
+                        if (canonicalWorkspaceSyncJson(accepted) === canonicalWorkspaceSyncJson(comment)) {
+                            return false;
+                        }
+                        // Reconciliation never rewrites an existing authoritative
+                        // cloud comment. A provenance-only difference therefore
+                        // installs the cloud actor while preserving stable identity.
+                        if (taskCommentBodiesMatchIgnoringProvenance(accepted, comment)) {
+                            return false;
+                        }
+                        throw new Error(`Task comment identity conflict: ${comment.id}.`);
+                    });
+                    installedPayload = mergeWorkspaceSyncV3TaskCommentsPayload({
+                        taskId: existing.id,
+                        left: authoritative.comments,
+                        right: localOnlySuccessors,
+                    });
+                }
+                catch (error) {
+                    throw new LocalAuthoritativeTaskCommentError(String(error?.message || 'Task comment identity conflict.'));
+                }
+            }
+            const updated = input.core.updateTask(existing.id, { comments: installedPayload.comments }, input.identity.workspaceId, {
+                persistBackup: false,
+                emitRealtime: false,
+                skipTaskEvents: true,
+                syncUpdatedAt: String(existing.updatedAt || existing.createdAt),
+                allowV3OwnedMetadataWrite: true,
+                allowArchivedNestedContentSyncWrite: true,
+            });
+            if (!updated) {
+                throw new LocalAuthoritativeTaskCommentError('Authoritative task comment reconciliation task disappeared locally.');
+            }
+            return updated;
+        },
+    });
+    try {
+        input.core.notifyDurableTaskMetadataCommitted(input.identity.workspaceId, comments.entityId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* authoritative state and ack remain committed */ }
+    }
+    return task;
+}

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

@@ -0,0 +1,27 @@
+import type { TaskItem } from '../../core/Taskforce.js';
+import { type LocalTaskCreateAttemptStore } from './localOperationIdentityStore.js';
+import { type LocalTaskOperationClientDependencies, type LocalTaskOperationResult } from './localTaskOperationClient.js';
+export type LocalTaskCreateMutationResult = LocalTaskOperationResult;
+export declare function createLocalTaskCreateClient(input?: LocalTaskOperationClientDependencies & {
+    attemptStore?: LocalTaskCreateAttemptStore;
+}): {
+    recoverPending(inputValue: {
+        workspaceId: string;
+        isAuthenticated: boolean;
+        dispatchEnabled?: boolean;
+    }): Promise<LocalTaskCreateMutationResult[]>;
+    create(inputValue: {
+        workspaceId: string;
+        participantId: string;
+        task: Partial<TaskItem>;
+        localTask?: Partial<TaskItem>;
+        isAuthenticated: boolean;
+        dispatchEnabled?: boolean;
+    }): Promise<LocalTaskCreateMutationResult>;
+    resumePending(inputValue: {
+        workspaceId: string;
+        participantId: string;
+        isAuthenticated: boolean;
+        dispatchEnabled?: boolean;
+    }): Promise<LocalTaskCreateMutationResult | null>;
+};

package/dist/sync/v3/localTaskCreateClient.js

@@ -0,0 +1,209 @@
+import { validateDurableTaskCreateInput } from '../../core/TaskDurableCreateMutationService.js';
+import { canonicalLocalOperationJson, IndexedDbLocalTaskCreateAttemptStore, } from './localOperationIdentityStore.js';
+import { createLocalTaskOperationClient, requireLocalTaskOperationId, } from './localTaskOperationClient.js';
+const CAPTURE_DISABLED_CODES = new Set([
+    'WORKSPACE_SYNC_LOCAL_CAPTURE_DISABLED',
+    'WORKSPACE_SYNC_LOCAL_CREATE_CAPTURE_DISABLED',
+]);
+const CAPTURE_PATH = '/api/taskforce/sync/v3/local/operations';
+function canonicalTaskInput(value) {
+    return JSON.parse(canonicalLocalOperationJson(validateDurableTaskCreateInput(value)));
+}
+function canonicalLocalTaskInput(value, expectedTask) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Local task create input must be an object.');
+    }
+    const source = value;
+    const { attachments = [], checklistItems = [], comments = [], ...root } = source;
+    if (!Array.isArray(attachments) || !Array.isArray(checklistItems) || !Array.isArray(comments)) {
+        throw new Error('Local task create carriers must be arrays.');
+    }
+    const canonicalRoot = canonicalTaskInput(root);
+    if (canonicalLocalOperationJson(canonicalRoot) !== canonicalLocalOperationJson(expectedTask)) {
+        throw new Error('Local task create root does not match its durable task.');
+    }
+    return JSON.parse(canonicalLocalOperationJson({ ...canonicalRoot, attachments, checklistItems, comments }));
+}
+export function createLocalTaskCreateClient(input = {}) {
+    const client = createLocalTaskOperationClient(input);
+    const attemptStore = input.attemptStore || new IndexedDbLocalTaskCreateAttemptStore();
+    const fetchImpl = input.fetchImpl || globalThis.fetch;
+    const lookupCapturedAttempt = async (workspaceId, participantId) => {
+        let response;
+        let body;
+        try {
+            response = await fetchImpl(`${CAPTURE_PATH}?workspaceId=${encodeURIComponent(workspaceId)}&operationId=${encodeURIComponent(participantId)}`, { method: 'GET', headers: { Accept: 'application/json' } });
+            body = await response.json();
+        }
+        catch {
+            return { state: 'ambiguous', phase: 'capture', fallbackEligible: false, operationId: participantId };
+        }
+        if (response.status === 404
+            && body?.success === false
+            && body?.code === 'WORKSPACE_SYNC_LOCAL_OPERATION_NOT_FOUND')
+            return null;
+        const operation = body?.operation;
+        const task = operation?.payload?.task;
+        const localCarriers = operation?.payload?.localCarriers;
+        if (!response.ok
+            || body?.success !== true
+            || body?.contractVersion !== 3
+            || body?.workspaceId !== workspaceId
+            || body?.operationId !== participantId
+            || operation?.domain !== 'task'
+            || operation?.entityId !== `task-${participantId}`
+            || operation?.mutationKind !== 'create') {
+            return {
+                state: 'ambiguous', phase: 'capture', fallbackEligible: false, operationId: participantId,
+                errorCode: typeof body?.code === 'string' ? body.code : undefined,
+            };
+        }
+        try {
+            const canonicalTask = canonicalTaskInput(task);
+            return {
+                workspaceId,
+                operationId: participantId,
+                task: canonicalLocalTaskInput({
+                    ...canonicalTask,
+                    ...(localCarriers && typeof localCarriers === 'object' ? localCarriers : {}),
+                }, canonicalTask),
+            };
+        }
+        catch {
+            return {
+                state: 'ambiguous', phase: 'capture', fallbackEligible: false, operationId: participantId,
+                errorCode: 'WORKSPACE_SYNC_LOCAL_REPLAY_INVALID',
+            };
+        }
+    };
+    const runAttempt = async (attempt, isAuthenticated, dispatchEnabled, recoveredChangedInput) => {
+        const result = await client.execute({
+            workspaceId: attempt.workspaceId,
+            preparedIdentity: {
+                key: attempt.workspaceId,
+                operationId: attempt.operationId,
+                // Create activation never grants legacy fallback after a page
+                // has entered durable capture. A stale capability response is
+                // recoverable only by replaying this exact retained identity.
+                created: false,
+                abandonIfMatches: (workspaceId, operationId) => attemptStore.abandonIfMatches(workspaceId, operationId),
+                markCaptureConfirmed: (workspaceId, operationId) => attemptStore.markResolved(workspaceId, operationId),
+            },
+            buildOperation: () => {
+                const { attachments, checklistItems, comments, ...task } = attempt.task;
+                return {
+                    domain: 'task',
+                    entityId: `task-${attempt.operationId}`,
+                    mutationKind: 'create',
+                    payload: {
+                        task: canonicalTaskInput(task),
+                        localCarriers: { attachments, checklistItems, comments },
+                    },
+                };
+            },
+            disabledCodes: CAPTURE_DISABLED_CODES,
+            isAuthenticated,
+            dispatchEnabled,
+        });
+        return recoveredChangedInput && (result.state === 'accepted' || result.state === 'pending' || result.state === 'blocked')
+            ? { ...result, recoveredChangedInput: true }
+            : result;
+    };
+    return {
+        async recoverPending(inputValue) {
+            const workspaceId = requireLocalTaskOperationId(inputValue.workspaceId, 'workspaceId');
+            let attempts;
+            try {
+                attempts = await attemptStore.listPending(workspaceId);
+            }
+            catch {
+                return [];
+            }
+            const results = [];
+            for (const attempt of attempts) {
+                results.push(await runAttempt(attempt, inputValue.isAuthenticated, inputValue.dispatchEnabled, false));
+            }
+            return results;
+        },
+        async create(inputValue) {
+            const workspaceId = requireLocalTaskOperationId(inputValue.workspaceId, 'workspaceId');
+            const task = canonicalTaskInput(inputValue.task);
+            const localTask = canonicalLocalTaskInput(inputValue.localTask || {
+                ...task,
+                attachments: [],
+                checklistItems: [],
+                comments: [],
+            }, task);
+            const participantId = requireLocalTaskOperationId(inputValue.participantId, 'participantId');
+            const captured = await lookupCapturedAttempt(workspaceId, participantId);
+            if (captured && 'state' in captured)
+                return captured;
+            if (captured) {
+                const changed = canonicalLocalOperationJson(captured.task) !== canonicalLocalOperationJson(localTask);
+                return runAttempt({ ...captured, created: false, resolved: true }, inputValue.isAuthenticated, inputValue.dispatchEnabled, changed);
+            }
+            let attempt;
+            try {
+                attempt = await attemptStore.claim(workspaceId, participantId, localTask, () => participantId);
+            }
+            catch {
+                return {
+                    state: 'failed', phase: 'prepare', fallbackEligible: false,
+                    errorCode: 'LOCAL_OPERATION_PREPARATION_FAILED',
+                };
+            }
+            try {
+                const { attachments, checklistItems, comments, ...attemptRoot } = attempt.task;
+                attempt = {
+                    ...attempt,
+                    task: canonicalLocalTaskInput({ ...attemptRoot, attachments, checklistItems, comments }, canonicalTaskInput(attemptRoot)),
+                };
+            }
+            catch {
+                return {
+                    state: 'failed', phase: 'prepare', fallbackEligible: false,
+                    errorCode: 'LOCAL_OPERATION_PREPARATION_FAILED',
+                };
+            }
+            const changed = !attempt.created
+                && canonicalLocalOperationJson(attempt.task) !== canonicalLocalOperationJson(localTask);
+            return runAttempt(attempt, inputValue.isAuthenticated, inputValue.dispatchEnabled, changed);
+        },
+        async resumePending(inputValue) {
+            const workspaceId = requireLocalTaskOperationId(inputValue.workspaceId, 'workspaceId');
+            const participantId = requireLocalTaskOperationId(inputValue.participantId, 'participantId');
+            const captured = await lookupCapturedAttempt(workspaceId, participantId);
+            if (captured && 'state' in captured)
+                return captured;
+            if (captured) {
+                return runAttempt({ ...captured, created: false, resolved: true }, inputValue.isAuthenticated, inputValue.dispatchEnabled, true);
+            }
+            let attempt;
+            try {
+                attempt = await attemptStore.getForParticipant(workspaceId, participantId);
+            }
+            catch {
+                return {
+                    state: 'failed', phase: 'prepare', fallbackEligible: false,
+                    errorCode: 'LOCAL_OPERATION_PREPARATION_FAILED',
+                };
+            }
+            if (!attempt)
+                return null;
+            try {
+                const { attachments, checklistItems, comments, ...attemptRoot } = attempt.task;
+                attempt = {
+                    ...attempt,
+                    task: canonicalLocalTaskInput({ ...attemptRoot, attachments, checklistItems, comments }, canonicalTaskInput(attemptRoot)),
+                };
+            }
+            catch {
+                return {
+                    state: 'failed', phase: 'prepare', fallbackEligible: false,
+                    errorCode: 'LOCAL_OPERATION_PREPARATION_FAILED',
+                };
+            }
+            return runAttempt(attempt, inputValue.isAuthenticated, inputValue.dispatchEnabled, true);
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+import { type LocalTaskCreateOutboxCore } from './localTaskCreateOutboxService.js';
+import type { LocalOutboxOperationHandler } from './localOutboxOperationHandler.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+export declare function createLocalTaskCreateOutboxHandler(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: LocalTaskCreateOutboxCore;
+    onPostCommitError?: (error: unknown) => void;
+}): LocalOutboxOperationHandler;