@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/v3/workspaceSyncV3NestedTaskProjection.js

@@ -0,0 +1,329 @@
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION } from './syncDurabilityStore.js';
+import { assertWorkspaceSyncV3OperationBoundary } from './workspaceSyncV3OperationProjection.js';
+import { projectWorkspaceSyncV3TaskRootJournalRow } from './workspaceSyncV3TaskRootProjection.js';
+import { projectWorkspaceSyncV3InitiativeJournalRow } from './workspaceSyncV3Feed.js';
+import { projectWorkspaceSyncV3WorkstreamJournalRow } from './workspaceSyncV3WorkstreamProjection.js';
+import { serializeWorkspaceSyncV3EntityEventPayload, validateWorkspaceSyncV3EntityEventPayload, validateWorkspaceSyncV3TaskAttachmentLinksPayload, validateWorkspaceSyncV3TaskChecklistPayload, validateWorkspaceSyncV3TaskCommentAppendPayload, validateWorkspaceSyncV3TaskCommentsPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+import { isLegacyEntityEventAdoptionIdentity } from './entityEventLegacyAdoptionContract.js';
+export const WORKSPACE_SYNC_V3_NESTED_TASK_PROJECTIONS = Object.freeze([
+    Object.freeze({
+        projectionId: 'task-comments/full-v1',
+        domain: 'task-comments',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['append', 'replace']),
+        fields: Object.freeze(['taskId', 'comments']),
+        dependencies: Object.freeze(['task/root-v1']),
+        operationAtomic: true,
+    }),
+    Object.freeze({
+        projectionId: 'task-checklist/full-v1',
+        domain: 'task-checklist',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['replace']),
+        fields: Object.freeze(['taskId', 'items']),
+        dependencies: Object.freeze(['task/root-v1']),
+        operationAtomic: true,
+    }),
+    Object.freeze({
+        projectionId: 'task-attachment-links/full-v1',
+        domain: 'task-attachment-links',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['replace']),
+        fields: Object.freeze(['taskId', 'links']),
+        dependencies: Object.freeze(['task/root-v1']),
+        operationAtomic: true,
+    }),
+    Object.freeze({
+        projectionId: 'entity-event/full-v1',
+        domain: 'entity-event',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['append']),
+        fields: Object.freeze([
+            'id', 'workspaceId', 'entityType', 'entityId', 'taskId', 'action', 'actor', 'actorType', 'details', 'createdAt',
+        ]),
+        dependencies: Object.freeze(['initiative/full-v1', 'workstream/full-v1', 'task/root-v1']),
+        operationAtomic: true,
+    }),
+]);
+const projectionByDomain = new Map(WORKSPACE_SYNC_V3_NESTED_TASK_PROJECTIONS.map((projection) => [projection.domain, projection.projectionId]));
+function sequence(value, label) {
+    const text = String(value ?? '').trim();
+    if (!/^\d+$/.test(text))
+        throw new Error(`${label} is invalid.`);
+    return BigInt(text).toString(10);
+}
+function canonicalTimestamp(value, label) {
+    const text = String(value || '').trim();
+    const parsed = Date.parse(text);
+    if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== text)
+        throw new Error(`${label} is invalid.`);
+    return text;
+}
+function parsePayload(row) {
+    try {
+        return JSON.parse(row.payloadJson);
+    }
+    catch {
+        throw new Error(`Nested task journal payload is malformed at ${row.sequence}.`);
+    }
+}
+function canonicalPayload(row) {
+    const raw = parsePayload(row);
+    if (row.domain === 'task-comments') {
+        if (row.mutationKind === 'append') {
+            const payload = validateWorkspaceSyncV3TaskCommentAppendPayload(raw);
+            if (payload.taskId !== row.entityId)
+                throw new Error(`Task comment identity is invalid at ${row.sequence}.`);
+            return { payload, canonicalFingerprint: payload.canonicalFingerprint };
+        }
+        if (row.mutationKind === 'replace') {
+            const payload = validateWorkspaceSyncV3TaskCommentsPayload(raw);
+            if (payload.taskId !== row.entityId)
+                throw new Error(`Task comments identity is invalid at ${row.sequence}.`);
+            return { payload, canonicalFingerprint: fingerprintWorkspaceSyncPayload(payload) };
+        }
+    }
+    if (row.domain === 'task-checklist' && row.mutationKind === 'replace') {
+        const payload = validateWorkspaceSyncV3TaskChecklistPayload(raw);
+        if (payload.taskId !== row.entityId)
+            throw new Error(`Task checklist identity is invalid at ${row.sequence}.`);
+        return { payload, canonicalFingerprint: fingerprintWorkspaceSyncPayload(payload) };
+    }
+    if (row.domain === 'task-attachment-links' && row.mutationKind === 'replace') {
+        const payload = validateWorkspaceSyncV3TaskAttachmentLinksPayload(raw);
+        if (payload.taskId !== row.entityId)
+            throw new Error(`Task attachment-link identity is invalid at ${row.sequence}.`);
+        return { payload, canonicalFingerprint: fingerprintWorkspaceSyncPayload(payload) };
+    }
+    if (row.domain === 'entity-event' && row.mutationKind === 'append') {
+        const payload = canonicalEntityEventPayload(raw);
+        if (payload.id !== row.entityId)
+            throw new Error(`Entity event identity is invalid at ${row.sequence}.`);
+        return { payload, canonicalFingerprint: fingerprintWorkspaceSyncPayload(payload) };
+    }
+    throw new Error(`Unsupported nested task journal mutation ${row.domain}/${row.mutationKind} at ${row.sequence}.`);
+}
+function canonicalEntityEventPayload(raw) {
+    return validateWorkspaceSyncV3EntityEventPayload(serializeWorkspaceSyncV3EntityEventPayload(raw));
+}
+export function projectWorkspaceSyncV3NestedTaskJournalRow(row) {
+    const projection = projectionByDomain.get(row.domain);
+    if (!projection)
+        return null;
+    if (row.contractVersion !== WORKSPACE_SYNC_CONTRACT_VERSION) {
+        throw new Error(`Unsupported nested task journal contract at ${row.sequence}.`);
+    }
+    const journalSequence = sequence(row.sequence, 'Nested task journal sequence');
+    if (BigInt(journalSequence) < 1n)
+        throw new Error('Nested task journal sequence must be positive.');
+    const entityRevision = sequence(row.entityRevision, `Nested task entity revision at ${row.sequence}`);
+    const lifecycleRevision = sequence(row.lifecycleRevision, `Nested task lifecycle revision at ${row.sequence}`);
+    if (BigInt(entityRevision) < 1n || lifecycleRevision !== '0') {
+        throw new Error(`Nested task journal revisions are invalid at ${row.sequence}.`);
+    }
+    if (row.contentSha256 !== null || row.sizeBytes !== null) {
+        throw new Error(`Nested task journal row carries content coordinates at ${row.sequence}.`);
+    }
+    const occurredAt = canonicalTimestamp(row.occurredAt, `Nested task occurredAt at ${row.sequence}`);
+    if (row.domain === 'entity-event') {
+        const payload = canonicalEntityEventPayload(parsePayload(row));
+        if (payload.action === 'sync-v3-repair-baseline')
+            return null;
+    }
+    const { payload, canonicalFingerprint } = canonicalPayload(row);
+    return {
+        sequence: journalSequence,
+        projection,
+        domain: row.domain,
+        entityId: row.entityId,
+        mutationKind: row.mutationKind,
+        entityRevision,
+        lifecycleRevision,
+        canonicalFingerprint,
+        payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+        payload,
+        occurredAt,
+    };
+}
+export function validateWorkspaceSyncV3NestedTaskFeedEntry(entry) {
+    const projected = projectWorkspaceSyncV3NestedTaskJournalRow({
+        sequence: entry.sequence,
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        clientId: 'validation-client',
+        operationId: 'validation-operation',
+        domain: entry.domain,
+        entityId: entry.entityId,
+        mutationKind: entry.mutationKind,
+        entityRevision: entry.entityRevision,
+        lifecycleRevision: entry.lifecycleRevision,
+        contentSha256: entry.contentSha256 ?? null,
+        sizeBytes: entry.sizeBytes ?? null,
+        payloadJson: canonicalWorkspaceSyncJson(entry.payload),
+        occurredAt: entry.occurredAt,
+    });
+    if (!projected || canonicalWorkspaceSyncJson(projected) !== canonicalWorkspaceSyncJson(entry)) {
+        throw new Error(`Nested task feed entry is invalid at ${entry.sequence}.`);
+    }
+}
+const dependentRank = new Map([
+    ['task-comments', 0],
+    ['task-checklist', 1],
+    ['task-attachment-links', 2],
+    ['entity-event', 3],
+]);
+function assertNestedDependentOrder(rows) {
+    const ranks = rows.map((row) => dependentRank.get(row.domain));
+    if (ranks.some((value) => value === undefined)
+        || ranks.some((value, index) => index > 0 && Number(ranks[index - 1]) > Number(value))
+        || rows.some((row, index) => row.domain !== 'entity-event'
+            && rows.slice(0, index).some((candidate) => candidate.domain === row.domain))) {
+        throw new Error('Nested task operation dependents are duplicated or out of order.');
+    }
+}
+function projectNestedDependentRows(rows) {
+    return rows.flatMap((row) => {
+        const projected = projectWorkspaceSyncV3NestedTaskJournalRow(row);
+        if (!projected) {
+            const payload = row.domain === 'entity-event'
+                ? canonicalEntityEventPayload(parsePayload(row))
+                : null;
+            if (payload?.action === 'sync-v3-repair-baseline')
+                return [];
+            throw new Error('Nested task dependent is not projectable.');
+        }
+        return [projected];
+    });
+}
+function isSupportedNestedOnlyOperation(rows) {
+    const first = rows[0];
+    if (!first)
+        return false;
+    const isRepair = first.clientId === 'sync-v3-repair'
+        && (first.operationId.startsWith('repair-baseline-')
+            || first.operationId.startsWith('repair-legacy-drift-'));
+    const isCommentReconcile = first.operationId.startsWith('task-comment-reconcile-')
+        && rows.length === 1
+        && first.domain === 'task-comments'
+        && first.mutationKind === 'replace';
+    const isLegacyEntityEventAdoption = isLegacyEntityEventAdoptionIdentity(first)
+        && rows.every((row) => (row.domain === 'entity-event'
+            && row.mutationKind === 'append'));
+    return isRepair || isCommentReconcile || isLegacyEntityEventAdoption;
+}
+/**
+ * Historical repair baselines, comment reconcile, and bounded legacy event
+ * adoption intentionally journal nested domains without a co-traveling parent
+ * root. Apply still requires referenced parents to exist on the receiver; feed
+ * only needs to project the nested rows.
+ */
+function projectNestedOnlyOperation(rows) {
+    if (!isSupportedNestedOnlyOperation(rows)) {
+        throw new Error('Nested-only task operation is not an allowed repair or reconciliation shape.');
+    }
+    assertNestedDependentOrder(rows);
+    const taskScoped = rows.filter((row) => row.domain !== 'entity-event');
+    if (taskScoped.length > 0) {
+        const taskId = taskScoped[0].entityId;
+        if (taskScoped.some((row) => row.entityId !== taskId)) {
+            throw new Error('Nested task operation dependent identity does not match its task root.');
+        }
+    }
+    const projected = projectNestedDependentRows(rows);
+    const events = projected
+        .filter((entry) => entry.domain === 'entity-event')
+        .map((entry) => validateWorkspaceSyncV3EntityEventPayload(entry.payload));
+    if (new Set(events.map((event) => event.id)).size !== events.length) {
+        throw new Error('Nested task operation contains duplicate entity-event identities.');
+    }
+    if (taskScoped.length > 0 && events.length > 0) {
+        const taskId = taskScoped[0].entityId;
+        const [primaryEvent, ...secondaryEvents] = events;
+        if (primaryEvent && (primaryEvent.entityType !== 'task' || primaryEvent.entityId !== taskId)) {
+            throw new Error('Nested task operation event identity does not match its parent root.');
+        }
+        if (secondaryEvents.some((event) => (event.entityType !== 'workstream' || event.details?.taskId !== taskId))) {
+            throw new Error('Task operation secondary activity does not describe workstream membership.');
+        }
+    }
+    if (events.length > 0 && projected.at(-1)?.domain !== 'entity-event') {
+        throw new Error('Nested task operation must end with entity activity.');
+    }
+    return projected;
+}
+/**
+ * Operation projector for nested/event coverage. Ordinary writers emit
+ * parent-first operations; repair baselines and comment reconcile may emit
+ * nested-only groups that still project when every row is a nested domain.
+ */
+export function projectWorkspaceSyncV3NestedTaskOperation(input) {
+    if (!input.rows.some((row) => projectionByDomain.has(row.domain)))
+        return null;
+    assertWorkspaceSyncV3OperationBoundary(input);
+    const [first, ...dependents] = input.rows;
+    if (first && projectionByDomain.has(first.domain)
+        && input.rows.every((row) => projectionByDomain.has(row.domain))) {
+        return projectNestedOnlyOperation(input.rows);
+    }
+    if (!first || !['task', 'initiative', 'workstream'].includes(first.domain)) {
+        throw new Error('Nested task operation must begin with its v3-owned parent root.');
+    }
+    if (dependents.some((row) => !projectionByDomain.has(row.domain))) {
+        throw new Error('Nested task operation contains an unsupported dependent row.');
+    }
+    assertNestedDependentOrder(dependents);
+    const projectedDependents = projectNestedDependentRows(dependents);
+    const eventRows = projectedDependents.filter((entry) => entry.domain === 'entity-event');
+    const rawEventRows = dependents.filter((row) => row.domain === 'entity-event');
+    const sentinelOnly = eventRows.length === 0 && rawEventRows.length > 0 && rawEventRows.every((row) => (canonicalEntityEventPayload(parsePayload(row)).action === 'sync-v3-repair-baseline'));
+    const nestedBodiesOnly = eventRows.length === 0
+        && projectedDependents.length > 0
+        && projectedDependents.every((entry) => entry.domain !== 'entity-event');
+    if (eventRows.length > 0 && eventRows.at(-1) !== projectedDependents.at(-1)) {
+        throw new Error('Nested task operation must end with entity activity.');
+    }
+    if (!sentinelOnly && !nestedBodiesOnly && eventRows.length < 1) {
+        throw new Error('Nested task operation must end with entity activity.');
+    }
+    if (first.domain !== 'task' && dependents.some((row) => row.domain !== 'entity-event')) {
+        throw new Error('Planning-root operations cannot contain task-nested dependents.');
+    }
+    if (first.domain === 'task'
+        && dependents.some((row) => row.domain !== 'entity-event' && row.entityId !== first.entityId)) {
+        throw new Error('Nested task operation dependent identity does not match its task root.');
+    }
+    const events = eventRows.map((entry) => validateWorkspaceSyncV3EntityEventPayload(entry.payload));
+    const [primaryEvent, ...secondaryEvents] = events;
+    if (primaryEvent && (primaryEvent.entityType !== first.domain || primaryEvent.entityId !== first.entityId)) {
+        throw new Error('Nested task operation event identity does not match its parent root.');
+    }
+    if (new Set(events.map((event) => event.id)).size !== events.length) {
+        throw new Error('Nested task operation contains duplicate entity-event identities.');
+    }
+    if (first.domain !== 'task' && secondaryEvents.length > 0) {
+        throw new Error('Planning-root operations cannot contain secondary entity activity.');
+    }
+    if (first.domain === 'task' && secondaryEvents.some((event) => (event.entityType !== 'workstream' || event.details?.taskId !== first.entityId))) {
+        throw new Error('Task operation secondary activity does not describe workstream membership.');
+    }
+    let parent;
+    if (first.domain === 'task') {
+        const projected = projectWorkspaceSyncV3TaskRootJournalRow(first);
+        if (!projected)
+            throw new Error('Nested task parent root is not projectable.');
+        parent = projected;
+    }
+    else if (first.domain === 'initiative') {
+        const projected = projectWorkspaceSyncV3InitiativeJournalRow(first);
+        if (!projected)
+            throw new Error('Nested task initiative parent is not projectable.');
+        parent = projected;
+    }
+    else {
+        const projected = projectWorkspaceSyncV3WorkstreamJournalRow(first);
+        if (!projected)
+            throw new Error('Nested task workstream parent is not projectable.');
+        parent = projected;
+    }
+    return [parent, ...projectedDependents];
+}

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

@@ -0,0 +1,19 @@
+import type { EntityEvent, TaskItem } from '../../types.js';
+import type { WorkspaceSyncV3ProjectionDescriptor } from './workspaceSyncV3FeedProfile.js';
+import { type WorkspaceSyncV3TaskAttachmentLink } from './workspaceSyncV3NestedTaskCodecs.js';
+export type WorkspaceSyncV3NestedTaskRepairCandidate = {
+    projection: Extract<WorkspaceSyncV3ProjectionDescriptor, 'task-comments/full-v1' | 'task-checklist/full-v1' | 'task-attachment-links/full-v1' | 'entity-event/full-v1'>;
+    domain: 'task-comments' | 'task-checklist' | 'task-attachment-links' | 'entity-event';
+    entityId: string;
+    mutationKind: 'replace' | 'append';
+    payload: unknown;
+};
+/**
+ * Produces deterministic metadata-only repair candidates. Revision and sequence
+ * coordinates are assigned later while the repair baseline lock is held.
+ */
+export declare function buildWorkspaceSyncV3NestedTaskRepairCandidates(input: {
+    tasks: readonly TaskItem[];
+    events: readonly EntityEvent[];
+    attachmentLinksByTaskId?: ReadonlyMap<string, readonly WorkspaceSyncV3TaskAttachmentLink[]>;
+}): WorkspaceSyncV3NestedTaskRepairCandidate[];

package/dist/sync/v3/workspaceSyncV3NestedTaskRepairSnapshot.js

@@ -0,0 +1,41 @@
+import { serializeWorkspaceSyncV3EntityEventPayload, serializeWorkspaceSyncV3TaskChecklistPayload, serializeWorkspaceSyncV3TaskCommentsPayload, validateWorkspaceSyncV3TaskAttachmentLinksPayload, } from './workspaceSyncV3NestedTaskCodecs.js';
+const rank = new Map([
+    ['task-comments/full-v1', 0],
+    ['task-checklist/full-v1', 1],
+    ['task-attachment-links/full-v1', 2],
+    ['entity-event/full-v1', 3],
+]);
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+ * Produces deterministic metadata-only repair candidates. Revision and sequence
+ * coordinates are assigned later while the repair baseline lock is held.
+ */
+export function buildWorkspaceSyncV3NestedTaskRepairCandidates(input) {
+    const candidates = [];
+    for (const task of input.tasks) {
+        const links = input.attachmentLinksByTaskId?.get(task.id);
+        if (!links) {
+            throw new Error(`Task attachment-link repair source is missing for ${task.id}.`);
+        }
+        candidates.push({
+            projection: 'task-comments/full-v1', domain: 'task-comments', entityId: task.id, mutationKind: 'replace',
+            payload: serializeWorkspaceSyncV3TaskCommentsPayload({ taskId: task.id, comments: task.comments || [] }),
+        }, {
+            projection: 'task-checklist/full-v1', domain: 'task-checklist', entityId: task.id, mutationKind: 'replace',
+            payload: serializeWorkspaceSyncV3TaskChecklistPayload({ taskId: task.id, items: task.checklistItems || [] }),
+        }, {
+            projection: 'task-attachment-links/full-v1', domain: 'task-attachment-links', entityId: task.id, mutationKind: 'replace',
+            payload: validateWorkspaceSyncV3TaskAttachmentLinksPayload({ taskId: task.id, links: links || [] }),
+        });
+    }
+    for (const event of input.events) {
+        const payload = serializeWorkspaceSyncV3EntityEventPayload(event);
+        candidates.push({
+            projection: 'entity-event/full-v1', domain: 'entity-event', entityId: payload.id, mutationKind: 'append', payload,
+        });
+    }
+    return candidates.sort((left, right) => (rank.get(left.projection) - rank.get(right.projection))
+        || compareCodeUnits(left.entityId, right.entityId));
+}

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

@@ -0,0 +1,6 @@
+export declare const WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR: Readonly<{
+    coverageProfileId: "task-planning-metadata";
+    coverageVersion: 4;
+    coverageDigest: "c622f33d62c9f9251559a5b3644ba617da31c1b53d4fd0927b529e76c89948d1";
+}>;
+export declare const WORKSPACE_SYNC_V3_NESTED_EXCLUDED_V2_PROJECTIONS: readonly ["task/root-v1", "task-relationship/full-v1", "taxonomy/full-v1", "initiative/full-v1", "workstream/full-v1", "task-comments/full-v1", "task-checklist/full-v1", "task-attachment-links/full-v1", "entity-event/full-v1"];

package/dist/sync/v3/workspaceSyncV3NestedWireContract.js

@@ -0,0 +1,16 @@
+export const WORKSPACE_SYNC_V3_NESTED_COVERAGE_SELECTOR = Object.freeze({
+    coverageProfileId: 'task-planning-metadata',
+    coverageVersion: 4,
+    coverageDigest: 'c622f33d62c9f9251559a5b3644ba617da31c1b53d4fd0927b529e76c89948d1',
+});
+export const WORKSPACE_SYNC_V3_NESTED_EXCLUDED_V2_PROJECTIONS = Object.freeze([
+    'task/root-v1',
+    'task-relationship/full-v1',
+    'taxonomy/full-v1',
+    'initiative/full-v1',
+    'workstream/full-v1',
+    'task-comments/full-v1',
+    'task-checklist/full-v1',
+    'task-attachment-links/full-v1',
+    'entity-event/full-v1',
+]);

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

@@ -0,0 +1,8 @@
+import type { WorkspaceSyncJournalRow } from './workspaceSyncJournalReader.js';
+export declare function canonicalWorkspaceSyncSequence(value: unknown, label: string): string;
+export declare function canonicalWorkspaceSyncTimestamp(value: unknown, label: string): string;
+export declare function assertWorkspaceSyncV3OperationBoundary(input: {
+    rows: readonly WorkspaceSyncJournalRow[];
+    cycleHighWatermark: string;
+    followingRow?: WorkspaceSyncJournalRow | null;
+}): void;

package/dist/sync/v3/workspaceSyncV3OperationProjection.js

@@ -0,0 +1,52 @@
+export function canonicalWorkspaceSyncSequence(value, label) {
+    const raw = String(value ?? '');
+    if (!/^\d+$/.test(raw))
+        throw new Error(`${label} must be a canonical non-negative integer.`);
+    const canonical = BigInt(raw).toString(10);
+    if (raw !== canonical)
+        throw new Error(`${label} must be a canonical non-negative integer.`);
+    return canonical;
+}
+export function canonicalWorkspaceSyncTimestamp(value, label) {
+    if (typeof value !== 'string' || !value)
+        throw new Error(`${label} must be a canonical ISO timestamp.`);
+    try {
+        if (new Date(value).toISOString() !== value)
+            throw new Error();
+    }
+    catch {
+        throw new Error(`${label} must be a canonical ISO timestamp.`);
+    }
+    return value;
+}
+export function assertWorkspaceSyncV3OperationBoundary(input) {
+    const { rows } = input;
+    if (rows.length === 0)
+        throw new Error('Workspace sync journal operation is empty.');
+    const first = rows[0];
+    if (!first.clientId || !first.operationId)
+        throw new Error('Workspace sync journal operation identity is incomplete.');
+    for (let index = 0; index < rows.length; index += 1) {
+        const row = rows[index];
+        canonicalWorkspaceSyncSequence(row.sequence, 'Journal sequence');
+        if (row.clientId !== first.clientId || row.operationId !== first.operationId) {
+            throw new Error('Workspace sync journal operation identity is inconsistent.');
+        }
+        if (index > 0 && BigInt(row.sequence) !== BigInt(rows[index - 1].sequence) + 1n) {
+            throw new Error('Workspace sync journal operation sequence is not contiguous.');
+        }
+    }
+    const highWatermark = canonicalWorkspaceSyncSequence(input.cycleHighWatermark, 'Cycle high watermark');
+    const lastSequence = rows.at(-1).sequence;
+    if (BigInt(lastSequence) > BigInt(highWatermark)) {
+        throw new Error('Workspace sync journal operation exceeds the cycle high watermark.');
+    }
+    if (lastSequence !== highWatermark) {
+        const following = input.followingRow;
+        if (!following
+            || BigInt(canonicalWorkspaceSyncSequence(following.sequence, 'Following journal sequence')) !== BigInt(lastSequence) + 1n
+            || (following.clientId === first.clientId && following.operationId === first.operationId)) {
+            throw new Error('Workspace sync journal operation terminal boundary is unproven.');
+        }
+    }
+}