@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/sync/v3/taskCreateActivation.js

@@ -0,0 +1,84 @@
+const DURABLE_CREATE_FIELDS = [
+    'title',
+    'description',
+    'priority',
+    'complexity',
+    'type',
+    'category',
+    'assignee',
+    'scheduledDate',
+    'dueDate',
+    'orderInDay',
+    'workstreamId',
+    'taxonomies',
+];
+const SIMPLE_FORM_FIELDS = new Set([
+    ...DURABLE_CREATE_FIELDS,
+    'status',
+    'completedAt',
+    'workstreamId',
+    'checklistItems',
+    'comments',
+    'attachments',
+    'createdAt',
+    'createdBy',
+]);
+function isEnabled(value) {
+    return /^(1|true|on|yes)$/i.test(String(value || '').trim());
+}
+/**
+ * Selects the strict task-create fields only when every still-legacy domain is
+ * in its default empty state. Unknown fields deliberately make the form
+ * ineligible so new form capabilities cannot enter v3 accidentally.
+ */
+export function selectTaskCreateActivationInput(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const source = value;
+    if (Object.keys(source).some((key) => !SIMPLE_FORM_FIELDS.has(key)))
+        return null;
+    if (source.status !== 'task' || source.completedAt !== null)
+        return null;
+    if (!Array.isArray(source.checklistItems) || !Array.isArray(source.comments) || !Array.isArray(source.attachments))
+        return null;
+    if (source.createdBy !== 'user')
+        return null;
+    const createdAt = String(source.createdAt || '').trim();
+    if (!Number.isFinite(Date.parse(createdAt)) || new Date(createdAt).toISOString() !== createdAt)
+        return null;
+    const selected = {};
+    for (const field of DURABLE_CREATE_FIELDS) {
+        if (Object.prototype.hasOwnProperty.call(source, field)) {
+            selected[field] = source[field];
+        }
+    }
+    return {
+        task: selected,
+        localTask: {
+            ...selected,
+            checklistItems: source.checklistItems,
+            comments: source.comments,
+            attachments: source.attachments,
+        },
+    };
+}
+export function selectStrictSimpleTaskCreateInput(value) {
+    const selected = selectTaskCreateActivationInput(value);
+    if (!selected)
+        return null;
+    if (selected.localTask.checklistItems?.length || selected.localTask.comments?.length || selected.localTask.attachments?.length) {
+        return null;
+    }
+    return selected.task;
+}
+export function resolveTaskCreateActivationCapability(input) {
+    const env = input.env || process.env;
+    return {
+        taskCreateActivation: input.runtimeMode === 'local'
+            && isEnabled(env.TASKFORCE_SYNC_V3_TASK_CREATE_ACTIVATION_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_TASK_CREATE_CAPTURE_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_TASKS_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_LOCAL_CAPTURE_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_LOCAL_DISPATCH_ENABLED),
+    };
+}

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

@@ -0,0 +1,7 @@
+export declare function isTaskCreateActivityEventId(value: unknown): boolean;
+export declare function buildTaskCreateActivityEventId(input: {
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    taskId: string;
+}): string;

package/dist/sync/v3/taskCreateActivityIdentity.js

@@ -0,0 +1,18 @@
+import { createHash } from 'crypto';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+const TASK_CREATE_ACTIVITY_EVENT_ID_PATTERN = /^entity-event-sync-v3-[a-f0-9]{64}$/;
+export function isTaskCreateActivityEventId(value) {
+    return TASK_CREATE_ACTIVITY_EVENT_ID_PATTERN.test(String(value || '').trim());
+}
+export function buildTaskCreateActivityEventId(input) {
+    const digest = createHash('sha256').update(canonicalWorkspaceSyncJson({
+        contractVersion: 3,
+        domain: 'task',
+        mutationKind: 'create',
+        workspaceId: String(input.workspaceId || '').trim(),
+        clientId: String(input.clientId || '').trim(),
+        operationId: String(input.operationId || '').trim(),
+        taskId: String(input.taskId || '').trim(),
+    }), 'utf8').digest('hex');
+    return `entity-event-sync-v3-${digest}`;
+}

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

@@ -0,0 +1,103 @@
+import { type DurableTaskCreateMutationCore } from '../../core/TaskDurableCreateMutationService.js';
+import type { EntityEvent, TaskEvent, TaskItem } from '../../core/Taskforce.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import type { WorkspaceSyncTaskEventSnapshot } from '../workspaceSyncModel.js';
+import { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, type WorkspaceSyncV3TaskAttachmentLink } from './workspaceSyncV3NestedTaskCodecs.js';
+import { type WorkspaceSyncActivityRevision } from './taskActivityJournal.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+export interface DurableTaskCreateServiceCore extends DurableTaskCreateMutationCore {
+    notifyDurableTaskCreateCommitted(workspaceId: string, taskId: string): void;
+    getTaskEventForSync(input: {
+        workspaceId: string;
+        taskId: string;
+        eventId: string;
+    }): TaskEvent | null;
+    getEntityEventForSync(input: {
+        workspaceId: string;
+        eventId: string;
+    }): EntityEvent | null;
+    listTaskAttachmentLinksForDurableSync(taskId: string, workspaceId: string): WorkspaceSyncV3TaskAttachmentLink[];
+    resolveTaskAttachmentLinksForDurableSync(links: readonly WorkspaceSyncV3TaskAttachmentLink[], workspaceId: string, options?: {
+        ignoreAssetMetadataSnapshots?: boolean;
+    }): TaskItem['attachments'];
+}
+export type DurableTaskCreateResponse = {
+    success: true;
+    contractVersion: 3;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    provisionalTaskId: string;
+    acceptedSequence: string;
+    operationHighWatermark: string;
+    authoritative: {
+        domain: 'task';
+        entityId: string;
+        mutationKind: 'create';
+        sequence: string;
+        entityRevision: string;
+        lifecycleRevision: string;
+        payload: ReturnType<typeof serializeTaskForSync>;
+    };
+    commentProjection?: {
+        domain: 'task-comments';
+        entityId: string;
+        mutationKind: 'replace';
+        sequence: string;
+        entityRevision: string;
+        lifecycleRevision: string;
+        payload: ReturnType<typeof serializeWorkspaceSyncV3TaskCommentsPayload>;
+    };
+    checklistProjection?: {
+        domain: 'task-checklist';
+        entityId: string;
+        mutationKind: 'replace';
+        sequence: string;
+        entityRevision: string;
+        lifecycleRevision: string;
+        payload: ReturnType<typeof serializeWorkspaceSyncV3TaskChecklistPayload>;
+    };
+    attachmentProjection?: {
+        domain: 'task-attachment-links';
+        entityId: string;
+        mutationKind: 'replace';
+        sequence: string;
+        entityRevision: string;
+        lifecycleRevision: string;
+        payload: ReturnType<typeof serializeWorkspaceSyncV3TaskAttachmentLinksPayload>;
+    };
+    activity: WorkspaceSyncTaskEventSnapshot;
+    activityRevision: WorkspaceSyncActivityRevision;
+    dependentActivities?: EntityEvent[];
+    dependentActivityRevisions?: WorkspaceSyncActivityRevision[];
+};
+export type DurableTaskCreateMutationResult = {
+    state: 'in_progress';
+    retryAt: string;
+} | {
+    state: 'committed';
+    replayed: boolean;
+    responseJson: string;
+    response: DurableTaskCreateResponse;
+};
+export declare function runDurableTaskCreate(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: DurableTaskCreateServiceCore;
+    tenantId: string;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    provisionalTaskId: string;
+    task: Partial<TaskItem>;
+    carriers?: Pick<TaskItem, 'attachments' | 'checklistItems' | 'comments'>;
+    attachmentLinks?: readonly WorkspaceSyncV3TaskAttachmentLink[];
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+    now: string;
+    leaseExpiresAt: string;
+    leaseOwner?: string;
+    actorRef: string;
+    originActorRef?: string;
+    resolveActorRef?: () => string;
+    onPostCommitError?: (error: unknown) => void;
+}): DurableTaskCreateMutationResult;

package/dist/sync/v3/taskCreateMutationService.js

@@ -0,0 +1,283 @@
+import { applyTaskCreateForDurableSync, assertTaskCreateIdentityAvailable, validateDurableTaskCreateInput, } from '../../core/TaskDurableCreateMutationService.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { buildTaskCreateActivityEventId } from './taskCreateActivityIdentity.js';
+import { serializeWorkspaceSyncV3TaskAttachmentLinksPayload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+import { asWorkspaceSyncActivityRevision, buildEntityActivityJournalEntry, buildTaskActivityJournalEntry, serializeTaskActivityForSync, } from './taskActivityJournal.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION, } from './syncDurabilityStore.js';
+function requireZeroBaseRevision(value, label) {
+    if (String(value).trim() !== '0')
+        throw new Error(`${label} must be 0 for task creation.`);
+}
+export function runDurableTaskCreate(input) {
+    const taskId = String(input.provisionalTaskId || '').trim();
+    if (!taskId)
+        throw new Error('Provisional task id is required.');
+    requireZeroBaseRevision(input.baseEntityRevision, 'Base entity revision');
+    requireZeroBaseRevision(input.baseLifecycleRevision, 'Base lifecycle revision');
+    const validatedTask = validateDurableTaskCreateInput(input.task);
+    const carriers = input.carriers;
+    if (carriers && (!Array.isArray(carriers.attachments)
+        || !Array.isArray(carriers.checklistItems)
+        || !Array.isArray(carriers.comments))) {
+        throw new Error('Task create carriers must be arrays.');
+    }
+    const attachmentLinks = serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+        taskId,
+        links: input.attachmentLinks || [],
+    }).links;
+    const identity = {
+        tenantId: input.tenantId,
+        workspaceId: input.workspaceId,
+        clientId: input.clientId,
+        operationId: input.operationId,
+    };
+    const activityEventId = buildTaskCreateActivityEventId({
+        workspaceId: input.workspaceId,
+        clientId: input.clientId,
+        operationId: input.operationId,
+        taskId,
+    });
+    const membershipAddedEventId = `${activityEventId}:workstream-added`;
+    const requestFingerprint = fingerprintWorkspaceSyncPayload({
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        identity,
+        operation: {
+            domain: 'task',
+            entityId: taskId,
+            mutationKind: 'create',
+            baseEntityRevision: '0',
+            baseLifecycleRevision: '0',
+            task: validatedTask,
+            ...(carriers ? { carriers } : {}),
+            ...(attachmentLinks.length > 0 ? { attachmentLinks } : {}),
+            ...(input.originActorRef ? { originActorRef: input.originActorRef } : {}),
+        },
+    });
+    const existingOperation = input.store.readOperation({ identity, requestFingerprint });
+    if (existingOperation?.state === 'committed') {
+        return {
+            state: 'committed',
+            replayed: true,
+            responseJson: existingOperation.responseJson,
+            response: JSON.parse(existingOperation.responseJson),
+        };
+    }
+    let reservation = existingOperation?.state === 'in_progress'
+        ? input.store.reserveOperation({
+            identity,
+            requestFingerprint,
+            now: input.now,
+            leaseExpiresAt: input.leaseExpiresAt,
+            leaseOwner: input.leaseOwner,
+        })
+        : null;
+    if (reservation?.state === 'in_progress')
+        return reservation;
+    if (reservation?.state === 'committed') {
+        return {
+            state: 'committed',
+            replayed: true,
+            responseJson: reservation.responseJson,
+            response: JSON.parse(reservation.responseJson),
+        };
+    }
+    try {
+        assertTaskCreateIdentityAvailable({ core: input.core, workspaceId: input.workspaceId, taskId });
+    }
+    catch (error) {
+        // A retried request may already hold a reservation (it was reserved on
+        // a prior in_progress replay above). Release it so this exact
+        // operation identity is immediately eligible for reservation takeover
+        // on the next retry instead of waiting out the lease.
+        if (reservation?.state === 'owned') {
+            input.store.releaseFailedOperationReservation({
+                identity, requestFingerprint, leaseOwner: reservation.leaseOwner, now: input.now,
+            });
+        }
+        throw error;
+    }
+    if (!reservation) {
+        reservation = input.store.reserveOperation({
+            identity,
+            requestFingerprint,
+            now: input.now,
+            leaseExpiresAt: input.leaseExpiresAt,
+            leaseOwner: input.leaseOwner,
+        });
+        if (reservation.state === 'in_progress')
+            return reservation;
+        if (reservation.state === 'committed') {
+            return {
+                state: 'committed',
+                replayed: true,
+                responseJson: reservation.responseJson,
+                response: JSON.parse(reservation.responseJson),
+            };
+        }
+    }
+    const readActivity = () => {
+        const activity = input.core.getTaskEventForSync({ workspaceId: input.workspaceId, taskId, eventId: activityEventId });
+        if (!activity)
+            throw new Error('Durable task create activity was not committed.');
+        return activity;
+    };
+    const accepted = input.store.acceptReservedOperationBatch({
+        identity,
+        requestFingerprint,
+        leaseOwner: reservation.leaseOwner,
+        now: input.now,
+        entries: [{
+                domain: 'task', entityId: taskId, mutationKind: 'create', revisionKind: 'metadata',
+                baseEntityRevision: 0, baseLifecycleRevision: 0,
+                buildCanonicalFingerprint: (task) => fingerprintWorkspaceSyncPayload(serializeTaskForSync(task)),
+                buildAuthoritativePayload: (task) => serializeTaskForSync(task),
+            }, {
+                domain: 'task-comments', entityId: taskId, mutationKind: 'replace', revisionKind: 'metadata',
+                baseEntityRevision: 0, baseLifecycleRevision: 0,
+                include: (task) => (task.comments || []).length > 0,
+                buildCanonicalFingerprint: (task) => fingerprintWorkspaceSyncPayload(serializeWorkspaceSyncV3TaskCommentsPayload({ taskId: task.id, comments: task.comments || [] })),
+                buildAuthoritativePayload: (task) => serializeWorkspaceSyncV3TaskCommentsPayload({
+                    taskId: task.id, comments: task.comments || [],
+                }),
+            }, {
+                domain: 'task-checklist', entityId: taskId, mutationKind: 'replace', revisionKind: 'metadata',
+                baseEntityRevision: 0, baseLifecycleRevision: 0,
+                include: (task) => (task.checklistItems || []).length > 0,
+                buildCanonicalFingerprint: (task) => fingerprintWorkspaceSyncPayload(serializeWorkspaceSyncV3TaskChecklistPayload({ taskId: task.id, items: task.checklistItems || [] })),
+                buildAuthoritativePayload: (task) => serializeWorkspaceSyncV3TaskChecklistPayload({
+                    taskId: task.id, items: task.checklistItems || [],
+                }),
+            }, {
+                domain: 'task-attachment-links', entityId: taskId, mutationKind: 'replace', revisionKind: 'metadata',
+                baseEntityRevision: 0, baseLifecycleRevision: 0,
+                include: () => attachmentLinks.length > 0,
+                buildCanonicalFingerprint: (task) => fingerprintWorkspaceSyncPayload(serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+                    taskId: task.id,
+                    links: input.core.listTaskAttachmentLinksForDurableSync(task.id, input.workspaceId),
+                })),
+                buildAuthoritativePayload: (task) => serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+                    taskId: task.id,
+                    links: input.core.listTaskAttachmentLinksForDurableSync(task.id, input.workspaceId),
+                }),
+            }, buildTaskActivityJournalEntry({ eventId: activityEventId, readEvent: readActivity }), {
+                ...buildEntityActivityJournalEntry({
+                    eventId: membershipAddedEventId,
+                    readEvent: () => input.core.getEntityEventForSync({
+                        workspaceId: input.workspaceId,
+                        eventId: membershipAddedEventId,
+                    }),
+                }),
+                include: (task) => Boolean(task.workstreamId),
+            }],
+        applyMutation: () => {
+            const contentActorRef = input.resolveActorRef?.() || input.actorRef;
+            const attachments = attachmentLinks.length > 0
+                ? input.core.resolveTaskAttachmentLinksForDurableSync(attachmentLinks, input.workspaceId, { ignoreAssetMetadataSnapshots: true })
+                : carriers?.attachments;
+            const effectiveCarriers = carriers || attachments !== undefined
+                ? {
+                    attachments: attachments || [],
+                    checklistItems: carriers?.checklistItems || [],
+                    comments: (carriers?.comments || []).map((comment) => ({
+                        ...comment,
+                        author: contentActorRef,
+                        submittedAuthor: contentActorRef,
+                    })),
+                }
+                : undefined;
+            return applyTaskCreateForDurableSync({
+                core: input.core,
+                workspaceId: input.workspaceId,
+                taskId,
+                task: validatedTask,
+                carriers: effectiveCarriers,
+                now: input.now,
+                actorRef: contentActorRef,
+                activityEventId,
+            });
+        },
+        buildResponse: (task, revisions) => {
+            const taskRevision = revisions[0];
+            const commentRevision = revisions.find((entry) => entry.domain === 'task-comments');
+            const checklistRevision = revisions.find((entry) => entry.domain === 'task-checklist');
+            const attachmentRevision = revisions.find((entry) => entry.domain === 'task-attachment-links');
+            const activityRevision = asWorkspaceSyncActivityRevision(revisions.find((entry) => entry.domain === 'entity-event'));
+            const dependentActivityRevisions = revisions
+                .filter((entry) => entry.domain === 'entity-event' && entry.entityId !== activityEventId)
+                .map(asWorkspaceSyncActivityRevision);
+            const dependentActivities = dependentActivityRevisions.map((revision) => {
+                const event = input.core.getEntityEventForSync({ workspaceId: input.workspaceId, eventId: revision.entityId });
+                if (!event)
+                    throw new Error('Dependent task create activity was not committed.');
+                return event;
+            });
+            const activity = readActivity();
+            return {
+                success: true,
+                contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+                workspaceId: input.workspaceId,
+                clientId: input.clientId,
+                operationId: input.operationId,
+                provisionalTaskId: taskId,
+                acceptedSequence: taskRevision.sequence,
+                operationHighWatermark: revisions.at(-1)?.sequence || activityRevision.sequence,
+                authoritative: {
+                    domain: 'task',
+                    entityId: task.id,
+                    mutationKind: 'create',
+                    sequence: taskRevision.sequence,
+                    entityRevision: taskRevision.entityRevision,
+                    lifecycleRevision: taskRevision.lifecycleRevision,
+                    payload: serializeTaskForSync(task),
+                },
+                ...(commentRevision ? { commentProjection: {
+                        domain: 'task-comments',
+                        entityId: task.id,
+                        mutationKind: 'replace',
+                        sequence: commentRevision.sequence,
+                        entityRevision: commentRevision.entityRevision,
+                        lifecycleRevision: commentRevision.lifecycleRevision,
+                        payload: serializeWorkspaceSyncV3TaskCommentsPayload({ taskId: task.id, comments: task.comments || [] }),
+                    } } : {}),
+                ...(checklistRevision ? { checklistProjection: {
+                        domain: 'task-checklist',
+                        entityId: task.id,
+                        mutationKind: 'replace',
+                        sequence: checklistRevision.sequence,
+                        entityRevision: checklistRevision.entityRevision,
+                        lifecycleRevision: checklistRevision.lifecycleRevision,
+                        payload: serializeWorkspaceSyncV3TaskChecklistPayload({
+                            taskId: task.id, items: task.checklistItems || [],
+                        }),
+                    } } : {}),
+                ...(attachmentRevision ? { attachmentProjection: {
+                        domain: 'task-attachment-links',
+                        entityId: task.id,
+                        mutationKind: 'replace',
+                        sequence: attachmentRevision.sequence,
+                        entityRevision: attachmentRevision.entityRevision,
+                        lifecycleRevision: attachmentRevision.lifecycleRevision,
+                        payload: serializeWorkspaceSyncV3TaskAttachmentLinksPayload({
+                            taskId: task.id,
+                            links: input.core.listTaskAttachmentLinksForDurableSync(task.id, input.workspaceId),
+                        }),
+                    } } : {}),
+                activity: serializeTaskActivityForSync(activity),
+                activityRevision,
+                ...(dependentActivities.length > 0 ? { dependentActivities } : {}),
+                ...(dependentActivityRevisions.length > 0 ? { dependentActivityRevisions } : {}),
+            };
+        },
+    });
+    const response = JSON.parse(accepted.responseJson);
+    try {
+        input.core.notifyDurableTaskCreateCommitted(input.workspaceId, taskId);
+    }
+    catch (error) {
+        try {
+            input.onPostCommitError?.(error);
+        }
+        catch { /* accepted mutation remains successful */ }
+    }
+    return { state: 'committed', replayed: false, responseJson: accepted.responseJson, response };
+}

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

@@ -0,0 +1,7 @@
+export type TaskDeleteActivationCapability = {
+    taskDeleteActivation: boolean;
+};
+export declare function resolveTaskDeleteActivationCapability(input: {
+    runtimeMode: 'local' | 'cloud';
+    env?: NodeJS.ProcessEnv;
+}): TaskDeleteActivationCapability;

package/dist/sync/v3/taskDeleteActivation.js

@@ -0,0 +1,14 @@
+function isEnabled(value) {
+    return /^(1|true|on|yes)$/i.test(String(value || '').trim());
+}
+export function resolveTaskDeleteActivationCapability(input) {
+    const env = input.env || process.env;
+    return {
+        taskDeleteActivation: input.runtimeMode === 'local'
+            && isEnabled(env.TASKFORCE_SYNC_V3_TASK_DELETE_ACTIVATION_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_TASK_DELETE_CAPTURE_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_TASKS_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_LOCAL_CAPTURE_ENABLED)
+            && isEnabled(env.TASKFORCE_SYNC_V3_LOCAL_DISPATCH_ENABLED),
+    };
+}

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

@@ -0,0 +1,35 @@
+import { type DurableTaskDeleteCore } from '../../core/TaskDurableDeleteMutationService.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+export interface DurableTaskDeleteServiceCore extends DurableTaskDeleteCore {
+    notifyDurableTaskDeleteCommitted(workspaceId: string, taskId: string): void;
+}
+export type DurableRelationshipBaseRevision = {
+    entityId: string;
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+};
+export declare function runDurableTaskDelete(input: {
+    store: WorkspaceSyncDurabilityStore;
+    core: DurableTaskDeleteServiceCore;
+    tenantId: string;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    taskId: string;
+    baseEntityRevision: string | number;
+    baseLifecycleRevision: string | number;
+    relationshipBaseRevisions: DurableRelationshipBaseRevision[];
+    now: string;
+    leaseExpiresAt: string;
+    leaseOwner?: string;
+    actorRef: string;
+    onPostCommitError?: (error: unknown) => void;
+}): {
+    state: 'in_progress';
+    retryAt: string;
+} | {
+    state: 'committed';
+    replayed: boolean;
+    responseJson: string;
+    acceptedSequence: string;
+};