@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/sync/v3/workspaceSyncV3TaskRootProjection.js

@@ -0,0 +1,246 @@
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION } from './syncDurabilityStore.js';
+import { serializeTaskForSync } from '../taskSyncPayload.js';
+import { projectWorkspaceSyncV3TaxonomyJournalRow, projectWorkspaceSyncV3TaxonomyOperation, } from './workspaceSyncV3TaxonomyFeedProjection.js';
+import { assertWorkspaceSyncV3OperationBoundary, canonicalWorkspaceSyncSequence, canonicalWorkspaceSyncTimestamp, } from './workspaceSyncV3OperationProjection.js';
+/**
+ * Behavior-dark operation contract. It is not an advertised coverage profile.
+ * Activation also requires taxonomy and task-relationship operation closure.
+ */
+export const WORKSPACE_SYNC_V3_TASK_ROOT_OPERATION_PROJECTION = Object.freeze({
+    projectionId: 'task/root-v1',
+    domain: 'task',
+    schemaVersion: 1,
+    mutationKinds: Object.freeze([
+        'create', 'metadata-update', 'archive', 'unarchive', 'complete', 'reopen', 'set-status', 'taxonomy-remap', 'delete',
+    ]),
+});
+const FULL_MUTATIONS = new Set([
+    'create', 'metadata-update', 'archive', 'unarchive', 'complete', 'reopen', 'set-status',
+]);
+const TASK_STATUSES = new Set(['task', 'on-hold', 'in-progress', 'review', 'done', 'cancelled']);
+function taskRootFromSerialized(task) {
+    const { attachments: _attachments, checklistItems: _checklistItems, comments: _comments, ...root } = task;
+    return root;
+}
+export function serializeTaskRootForSync(task) {
+    return taskRootFromSerialized(serializeTaskForSync(task));
+}
+function parsePayload(row) {
+    try {
+        return JSON.parse(row.payloadJson);
+    }
+    catch {
+        throw new Error(`Malformed task journal payload at ${row.sequence}.`);
+    }
+}
+function assertBaseRow(row) {
+    canonicalWorkspaceSyncSequence(row.sequence, 'Task journal sequence');
+    const entityRevision = canonicalWorkspaceSyncSequence(row.entityRevision, 'Task entity revision');
+    const lifecycleRevision = canonicalWorkspaceSyncSequence(row.lifecycleRevision, 'Task lifecycle revision');
+    canonicalWorkspaceSyncTimestamp(row.occurredAt, 'Task journal occurredAt');
+    if (row.contractVersion !== WORKSPACE_SYNC_CONTRACT_VERSION || row.domain !== 'task' || !row.entityId) {
+        throw new Error(`Task journal identity is invalid at ${row.sequence}.`);
+    }
+    if (BigInt(entityRevision) < 1n || BigInt(lifecycleRevision) > BigInt(entityRevision)) {
+        throw new Error(`Task journal revisions are invalid at ${row.sequence}.`);
+    }
+    if (row.contentSha256 !== null || row.sizeBytes !== null) {
+        throw new Error(`Task journal row carries content coordinates at ${row.sequence}.`);
+    }
+    return { entityRevision, lifecycleRevision };
+}
+function legacyCommentActorDecoratedPayload(full, raw) {
+    const rawComments = raw.comments;
+    if (!Array.isArray(rawComments) || !Array.isArray(full.comments) || rawComments.length !== full.comments.length) {
+        return full;
+    }
+    return {
+        ...full,
+        comments: full.comments.map((comment, index) => {
+            const source = rawComments[index];
+            if (!source || typeof source !== 'object' || Array.isArray(source)
+                || !Object.prototype.hasOwnProperty.call(source, 'actor'))
+                return comment;
+            return { ...comment, actor: source.actor };
+        }),
+    };
+}
+function withoutRetiredApproach(raw) {
+    const { approach: _approach, ...current } = raw;
+    if (!current.taxonomies || typeof current.taxonomies !== 'object' || Array.isArray(current.taxonomies)) {
+        return current;
+    }
+    const { approach: _taxonomyApproach, ...taxonomies } = current.taxonomies;
+    return { ...current, taxonomies };
+}
+function canonicalFullPayload(row, raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(`Task payload is invalid at ${row.sequence}.`);
+    }
+    const rawRecord = raw;
+    const full = serializeTaskForSync(rawRecord);
+    const currentRaw = withoutRetiredApproach(rawRecord);
+    const canonicalRaw = canonicalWorkspaceSyncJson(rawRecord);
+    const canonicalCurrentRaw = canonicalWorkspaceSyncJson(currentRaw);
+    const canonicalFull = canonicalWorkspaceSyncJson(full);
+    const canonicalLegacy = canonicalWorkspaceSyncJson(legacyCommentActorDecoratedPayload(full, currentRaw));
+    const matchesCurrent = canonicalFull === canonicalRaw || canonicalFull === canonicalCurrentRaw;
+    const matchesLegacy = canonicalLegacy === canonicalRaw || canonicalLegacy === canonicalCurrentRaw;
+    if (full.id !== row.entityId || (!matchesCurrent && !matchesLegacy)) {
+        throw new Error(`Task payload is not canonical at ${row.sequence}.`);
+    }
+    if (!full.title || !full.type || !full.category || !TASK_STATUSES.has(full.status)) {
+        throw new Error(`Task root fields are invalid at ${row.sequence}.`);
+    }
+    canonicalWorkspaceSyncTimestamp(full.createdAt, 'Task createdAt');
+    canonicalWorkspaceSyncTimestamp(full.updatedAt, 'Task updatedAt');
+    return full;
+}
+function canonicalTombstone(row, raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(`Task tombstone is invalid at ${row.sequence}.`);
+    }
+    const source = raw;
+    const keys = Object.keys(source).sort();
+    if (keys.length !== 2 || keys[0] !== 'deletedAt' || keys[1] !== 'taskId' || source.taskId !== row.entityId) {
+        throw new Error(`Task tombstone is not canonical at ${row.sequence}.`);
+    }
+    return { taskId: row.entityId, deletedAt: canonicalWorkspaceSyncTimestamp(source.deletedAt, 'Task deletedAt') };
+}
+function assertMutationSemantics(row, payload, entityRevision, lifecycleRevision) {
+    if (row.mutationKind === 'create') {
+        const task = payload;
+        if (entityRevision !== '1' || lifecycleRevision !== '0' || task.isArchived === true
+            || !Number.isInteger(task.referenceNumber) || Number(task.referenceNumber) < 1) {
+            throw new Error(`Task create projection is invalid at ${row.sequence}.`);
+        }
+        return;
+    }
+    if (['archive', 'unarchive', 'complete', 'reopen', 'set-status', 'delete'].includes(row.mutationKind)
+        && BigInt(lifecycleRevision) < 1n) {
+        throw new Error(`Task lifecycle projection is invalid at ${row.sequence}.`);
+    }
+    if (row.mutationKind === 'delete')
+        return;
+    const task = payload;
+    if (row.mutationKind === 'archive' && task.isArchived !== true) {
+        throw new Error(`Task archive projection is active at ${row.sequence}.`);
+    }
+    if (['unarchive', 'complete', 'reopen', 'set-status'].includes(row.mutationKind) && task.isArchived === true) {
+        throw new Error(`Active task projection is archived at ${row.sequence}.`);
+    }
+    if (row.mutationKind === 'complete' && task.status !== 'done') {
+        throw new Error(`Task complete projection is not done at ${row.sequence}.`);
+    }
+    if (row.mutationKind === 'reopen' && task.status !== 'in-progress') {
+        throw new Error(`Task reopen projection is not in progress at ${row.sequence}.`);
+    }
+}
+export function projectWorkspaceSyncV3TaskRootJournalRow(row) {
+    if (row.domain !== 'task')
+        return null;
+    const { entityRevision, lifecycleRevision } = assertBaseRow(row);
+    const mutationKind = row.mutationKind;
+    let payload;
+    let canonicalFingerprint;
+    if (FULL_MUTATIONS.has(mutationKind)) {
+        const fullPayload = parsePayload(row);
+        const canonicalFull = canonicalFullPayload(row, fullPayload);
+        payload = taskRootFromSerialized(canonicalFull);
+        canonicalFingerprint = fingerprintWorkspaceSyncPayload(canonicalFull);
+        assertMutationSemantics(row, payload, entityRevision, lifecycleRevision);
+    }
+    else if (mutationKind === 'taxonomy-remap') {
+        const projected = projectWorkspaceSyncV3TaxonomyJournalRow(row);
+        if (!projected || projected.projection !== 'task/taxonomy-remap-v1') {
+            throw new Error(`Task taxonomy-remap projection is invalid at ${row.sequence}.`);
+        }
+        payload = projected.payload;
+        canonicalFingerprint = projected.payloadFingerprint;
+    }
+    else if (mutationKind === 'delete') {
+        payload = canonicalTombstone(row, parsePayload(row));
+        canonicalFingerprint = fingerprintWorkspaceSyncPayload(payload);
+        assertMutationSemantics(row, payload, entityRevision, lifecycleRevision);
+    }
+    else {
+        throw new Error(`Unsupported task root mutation at ${row.sequence}: ${row.mutationKind}.`);
+    }
+    return {
+        sequence: row.sequence,
+        projection: 'task/root-v1',
+        domain: 'task',
+        entityId: row.entityId,
+        mutationKind,
+        entityRevision,
+        lifecycleRevision,
+        canonicalFingerprint,
+        payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+        payload,
+        occurredAt: row.occurredAt,
+    };
+}
+export function projectWorkspaceSyncV3TaskRootOperation(input) {
+    const taskRows = input.rows.filter((row) => row.domain === 'task');
+    if (taskRows.length === 0)
+        return null;
+    assertWorkspaceSyncV3OperationBoundary(input);
+    const first = input.rows[0];
+    if (first.domain === 'taxonomy') {
+        const taxonomy = projectWorkspaceSyncV3TaxonomyOperation(input);
+        if (!taxonomy)
+            throw new Error('Task taxonomy-remap operation is invalid.');
+        return taskRows.map((row) => projectWorkspaceSyncV3TaskRootJournalRow(row));
+    }
+    if (first.domain !== 'task' || taskRows.length !== 1) {
+        throw new Error('Task root operation shape is invalid.');
+    }
+    if (first.mutationKind === 'taxonomy-remap') {
+        throw new Error('Task taxonomy-remap requires a taxonomy-first composite operation.');
+    }
+    if (first.mutationKind === 'delete') {
+        if (input.rows.slice(1).some((row) => row.domain !== 'task-relationship' || row.mutationKind !== 'delete')) {
+            throw new Error('Task delete operation contains an invalid dependent row.');
+        }
+        const relationshipIds = input.rows.slice(1).map((row) => row.entityId);
+        if (relationshipIds.some((id, index) => index > 0 && relationshipIds[index - 1] >= id)) {
+            throw new Error('Task delete relationship tombstones must be unique and ascending.');
+        }
+    }
+    else {
+        const dependents = input.rows.slice(1);
+        const requiresActivity = ['create', 'metadata-update', 'archive', 'unarchive'].includes(first.mutationKind);
+        if ((requiresActivity && dependents.length < 1)
+            || dependents.some((row) => row.domain !== 'entity-event' || row.mutationKind !== 'append')) {
+            throw new Error('Task root operation contains an invalid activity shape.');
+        }
+    }
+    return [projectWorkspaceSyncV3TaskRootJournalRow(first)];
+}
+export function validateWorkspaceSyncV3TaskRootFeedEntry(entry) {
+    const projected = projectWorkspaceSyncV3TaskRootJournalRow({
+        sequence: entry.sequence,
+        contractVersion: WORKSPACE_SYNC_CONTRACT_VERSION,
+        clientId: 'validation-client',
+        operationId: 'validation-operation',
+        domain: 'task',
+        entityId: entry.entityId,
+        mutationKind: entry.mutationKind,
+        entityRevision: entry.entityRevision,
+        lifecycleRevision: entry.lifecycleRevision,
+        contentSha256: null,
+        sizeBytes: null,
+        payloadJson: canonicalWorkspaceSyncJson(entry.payload),
+        occurredAt: entry.occurredAt,
+    });
+    const canonicalFingerprint = String(entry.canonicalFingerprint || '');
+    const projectedWithoutCanonical = projected && { ...projected, canonicalFingerprint: undefined };
+    const entryWithoutCanonical = { ...entry, canonicalFingerprint: undefined };
+    if (!/^[a-f0-9]{64}$/.test(canonicalFingerprint)
+        || !projected
+        || canonicalWorkspaceSyncJson(projectedWithoutCanonical) !== canonicalWorkspaceSyncJson(entryWithoutCanonical)
+        || (!FULL_MUTATIONS.has(entry.mutationKind) && canonicalFingerprint !== entry.payloadFingerprint)) {
+        throw new Error(`Task root feed entry is invalid at ${entry.sequence}.`);
+    }
+}

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

@@ -0,0 +1,39 @@
+import { type TaxonomyTaskRemapAuthoritativePayload } from './taxonomyCompositeMutationService.js';
+import { validateCanonicalTaxonomyState } from './taxonomySyncPayload.js';
+import type { WorkspaceSyncJournalRow } from './workspaceSyncJournalReader.js';
+export type WorkspaceSyncV3TaxonomyProjectionDescriptor = 'taxonomy/full-v1' | 'task/taxonomy-remap-v1';
+/**
+ * Behavior-dark journal-shape contract only. These projections must not be
+ * added to an advertised coverage profile until task-root ownership is closed.
+ * Ordinary task metadata/create writers also own category/type/priority.
+ */
+export declare const WORKSPACE_SYNC_V3_TAXONOMY_OPERATION_PROJECTIONS: readonly [Readonly<{
+    projectionId: "taxonomy/full-v1";
+    domain: "taxonomy";
+    schemaVersion: 1;
+    mutationKinds: readonly string[];
+}>, Readonly<{
+    projectionId: "task/taxonomy-remap-v1";
+    domain: "task";
+    schemaVersion: 1;
+    mutationKinds: readonly string[];
+}>];
+export type WorkspaceSyncV3TaxonomyFeedEntry = {
+    sequence: string;
+    projection: WorkspaceSyncV3TaxonomyProjectionDescriptor;
+    domain: 'taxonomy' | 'task';
+    entityId: string;
+    mutationKind: 'replace-state' | 'replace-state-with-task-remaps' | 'taxonomy-remap';
+    entityRevision: string;
+    lifecycleRevision: string;
+    payloadFingerprint: string;
+    payload: ReturnType<typeof validateCanonicalTaxonomyState> | TaxonomyTaskRemapAuthoritativePayload;
+    occurredAt: string;
+};
+export declare function projectWorkspaceSyncV3TaxonomyJournalRow(row: WorkspaceSyncJournalRow): WorkspaceSyncV3TaxonomyFeedEntry | null;
+export declare function projectWorkspaceSyncV3TaxonomyOperation(input: {
+    rows: readonly WorkspaceSyncJournalRow[];
+    cycleHighWatermark: string;
+    followingRow?: WorkspaceSyncJournalRow | null;
+}): WorkspaceSyncV3TaxonomyFeedEntry[] | null;
+export declare function validateWorkspaceSyncV3TaxonomyFeedEntry(entry: WorkspaceSyncV3TaxonomyFeedEntry): void;

package/dist/sync/v3/workspaceSyncV3TaxonomyFeedProjection.js

@@ -0,0 +1,185 @@
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { fingerprintWorkspaceSyncPayload, WORKSPACE_SYNC_CONTRACT_VERSION } from './syncDurabilityStore.js';
+import { serializeTaxonomyTaskRemapProjection, WORKSPACE_SYNC_TAXONOMY_REPLACE_WITH_REMAPS, } from './taxonomyCompositeMutationService.js';
+import { WORKSPACE_SYNC_TAXONOMY_DOMAIN, WORKSPACE_SYNC_TAXONOMY_ENTITY_ID, WORKSPACE_SYNC_TAXONOMY_REPLACE_STATE, } from './taxonomyMutationService.js';
+import { validateCanonicalTaxonomyState } from './taxonomySyncPayload.js';
+import { assertWorkspaceSyncV3OperationBoundary, canonicalWorkspaceSyncSequence, canonicalWorkspaceSyncTimestamp, } from './workspaceSyncV3OperationProjection.js';
+/**
+ * Behavior-dark journal-shape contract only. These projections must not be
+ * added to an advertised coverage profile until task-root ownership is closed.
+ * Ordinary task metadata/create writers also own category/type/priority.
+ */
+export const WORKSPACE_SYNC_V3_TAXONOMY_OPERATION_PROJECTIONS = Object.freeze([
+    Object.freeze({
+        projectionId: 'taxonomy/full-v1',
+        domain: 'taxonomy',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['replace-state', 'replace-state-with-task-remaps']),
+    }),
+    Object.freeze({
+        projectionId: 'task/taxonomy-remap-v1',
+        domain: 'task',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['taxonomy-remap']),
+    }),
+]);
+function assertMetadataOnly(value, path = 'payload') {
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => assertMetadataOnly(entry, `${path}[${index}]`));
+        return;
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === 'content' || key === 'contentBase64') {
+            throw new Error(`${path}.${key} cannot enter the metadata feed.`);
+        }
+        assertMetadataOnly(entry, `${path}.${key}`);
+    }
+}
+function assertBaseRow(row) {
+    canonicalWorkspaceSyncSequence(row.sequence, 'Journal sequence');
+    canonicalWorkspaceSyncSequence(row.entityRevision, 'Entity revision');
+    canonicalWorkspaceSyncSequence(row.lifecycleRevision, 'Lifecycle revision');
+    if (row.contractVersion !== WORKSPACE_SYNC_CONTRACT_VERSION) {
+        throw new Error(`Unsupported journal contract at ${row.sequence}.`);
+    }
+    if (!row.clientId || !row.operationId || !row.entityId) {
+        throw new Error(`Incomplete taxonomy journal coordinates at ${row.sequence}.`);
+    }
+    canonicalWorkspaceSyncTimestamp(row.occurredAt, 'Journal occurredAt');
+    if (row.contentSha256 !== null || row.sizeBytes !== null) {
+        throw new Error(`Taxonomy journal row carries content coordinates at ${row.sequence}.`);
+    }
+}
+function parsePayload(row) {
+    try {
+        const payload = JSON.parse(row.payloadJson);
+        assertMetadataOnly(payload);
+        return payload;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error(`Malformed journal payload at ${row.sequence}.`);
+        throw error;
+    }
+}
+function canonicalTaskRemapPayload(payload, entityId, label) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new Error(`Task taxonomy-remap payload is invalid at ${label}.`);
+    }
+    const source = payload;
+    const keys = Object.keys(source).sort();
+    const expected = ['category', 'id', 'priority', 'type', 'updatedAt'];
+    if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
+        throw new Error(`Task taxonomy-remap payload is not canonical at ${label}.`);
+    }
+    if (source.id !== entityId || typeof source.category !== 'string' || !source.category
+        || typeof source.type !== 'string' || !source.type || !Number.isInteger(source.priority)
+        || typeof source.updatedAt !== 'string' || !source.updatedAt) {
+        throw new Error(`Task taxonomy-remap payload is invalid at ${label}.`);
+    }
+    canonicalWorkspaceSyncTimestamp(source.updatedAt, 'Task taxonomy-remap updatedAt');
+    const canonical = serializeTaxonomyTaskRemapProjection(source);
+    if (canonicalWorkspaceSyncJson(canonical) !== canonicalWorkspaceSyncJson(payload)) {
+        throw new Error(`Task taxonomy-remap payload is not canonical at ${label}.`);
+    }
+    return canonical;
+}
+export function projectWorkspaceSyncV3TaxonomyJournalRow(row) {
+    const isTaxonomy = row.domain === WORKSPACE_SYNC_TAXONOMY_DOMAIN;
+    const isTaskRemap = row.domain === 'task' && row.mutationKind === 'taxonomy-remap';
+    if (!isTaxonomy && !isTaskRemap)
+        return null;
+    assertBaseRow(row);
+    const entityRevision = canonicalWorkspaceSyncSequence(row.entityRevision, 'Entity revision');
+    const lifecycleRevision = canonicalWorkspaceSyncSequence(row.lifecycleRevision, 'Lifecycle revision');
+    if (BigInt(entityRevision) < 1n || BigInt(lifecycleRevision) > BigInt(entityRevision)) {
+        throw new Error(`Taxonomy feed revisions are invalid at ${row.sequence}.`);
+    }
+    const rawPayload = parsePayload(row);
+    if (isTaxonomy) {
+        if (row.entityId !== WORKSPACE_SYNC_TAXONOMY_ENTITY_ID
+            || (row.mutationKind !== WORKSPACE_SYNC_TAXONOMY_REPLACE_STATE
+                && row.mutationKind !== WORKSPACE_SYNC_TAXONOMY_REPLACE_WITH_REMAPS)
+            || lifecycleRevision !== '0') {
+            throw new Error(`Taxonomy journal identity is invalid at ${row.sequence}.`);
+        }
+        const payload = validateCanonicalTaxonomyState(rawPayload);
+        return {
+            sequence: row.sequence,
+            projection: 'taxonomy/full-v1',
+            domain: 'taxonomy',
+            entityId: row.entityId,
+            mutationKind: row.mutationKind,
+            entityRevision,
+            lifecycleRevision,
+            payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+            payload,
+            occurredAt: row.occurredAt,
+        };
+    }
+    if (row.mutationKind !== 'taxonomy-remap')
+        return null;
+    const payload = canonicalTaskRemapPayload(rawPayload, row.entityId, row.sequence);
+    return {
+        sequence: row.sequence,
+        projection: 'task/taxonomy-remap-v1',
+        domain: 'task',
+        entityId: row.entityId,
+        mutationKind: 'taxonomy-remap',
+        entityRevision,
+        lifecycleRevision,
+        payloadFingerprint: fingerprintWorkspaceSyncPayload(payload),
+        payload,
+        occurredAt: row.occurredAt,
+    };
+}
+export function projectWorkspaceSyncV3TaxonomyOperation(input) {
+    const { rows } = input;
+    const candidateRows = rows.filter((row) => row.domain === WORKSPACE_SYNC_TAXONOMY_DOMAIN
+        || (row.domain === 'task' && row.mutationKind === 'taxonomy-remap'));
+    if (candidateRows.length === 0)
+        return null;
+    if (candidateRows.length !== rows.length || rows[0].domain !== WORKSPACE_SYNC_TAXONOMY_DOMAIN) {
+        throw new Error('Taxonomy journal operation contains an unsupported projection boundary.');
+    }
+    assertWorkspaceSyncV3OperationBoundary(input);
+    const first = rows[0];
+    const isComposite = first.mutationKind === WORKSPACE_SYNC_TAXONOMY_REPLACE_WITH_REMAPS;
+    if ((!isComposite && rows.length !== 1) || (isComposite && rows.length < 2)) {
+        throw new Error('Taxonomy journal operation shape is incomplete.');
+    }
+    for (let index = 1; index < rows.length; index += 1) {
+        if (rows[index].domain !== 'task' || rows[index].mutationKind !== 'taxonomy-remap'
+            || (index > 1 && rows[index - 1].entityId >= rows[index].entityId)) {
+            throw new Error('Taxonomy task-remap entries must be unique and ascending.');
+        }
+    }
+    return rows.map((row) => {
+        const projected = projectWorkspaceSyncV3TaxonomyJournalRow(row);
+        if (!projected)
+            throw new Error('Taxonomy journal operation contains an uncovered row.');
+        return projected;
+    });
+}
+export function validateWorkspaceSyncV3TaxonomyFeedEntry(entry) {
+    const projected = projectWorkspaceSyncV3TaxonomyJournalRow({
+        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: null,
+        sizeBytes: null,
+        payloadJson: canonicalWorkspaceSyncJson(entry.payload),
+        occurredAt: entry.occurredAt,
+    });
+    if (!projected || canonicalWorkspaceSyncJson(projected) !== canonicalWorkspaceSyncJson(entry)) {
+        throw new Error(`Taxonomy feed entry is invalid at ${entry.sequence}.`);
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { WorkspaceSyncV3FeedCoveragePolicy, WorkspaceSyncV3FeedEntry, WorkspaceSyncV3FeedOperationProjector } from './workspaceSyncV3Feed.js';
+import type { WorkspaceSyncV3CoverageProfile } from './workspaceSyncV3FeedProfile.js';
+/**
+ * Frozen workflow-inclusive contract for Slice 4. Registration makes the
+ * contract testable; the active wire selector and ownership remain on v4.
+ */
+export declare const WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE: WorkspaceSyncV3CoverageProfile;
+export declare const projectWorkspaceSyncV3WorkflowCoverageOperation: WorkspaceSyncV3FeedOperationProjector;
+export declare const WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_POLICY: WorkspaceSyncV3FeedCoveragePolicy;
+export declare function validateWorkspaceSyncV3WorkflowCoverageFeedEntry(entry: WorkspaceSyncV3FeedEntry): void;

package/dist/sync/v3/workspaceSyncV3WorkflowCoverage.js

@@ -0,0 +1,36 @@
+import { createHash } from 'crypto';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { projectWorkspaceSyncV3NestedCoverageOperation, validateWorkspaceSyncV3NestedCoverageFeedEntry, WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE, } from './workspaceSyncV3NestedCoverage.js';
+import { WORKSPACE_SYNC_V3_WORKFLOW_RUNTIME_PROJECTIONS, } from './workflowRuntimeSync.js';
+import { projectWorkspaceSyncV3WorkflowRuntimeOperation, validateWorkspaceSyncV3WorkflowRuntimeFeedEntry, } from './workspaceSyncV3WorkflowRuntimeProjection.js';
+const projections = Object.freeze([
+    ...WORKSPACE_SYNC_V3_NESTED_COVERAGE_PROFILE.projections,
+    ...WORKSPACE_SYNC_V3_WORKFLOW_RUNTIME_PROJECTIONS,
+]);
+const identity = Object.freeze({
+    coverageProfileId: 'task-planning-metadata',
+    coverageVersion: 5,
+    projections,
+});
+/**
+ * Frozen workflow-inclusive contract for Slice 4. Registration makes the
+ * contract testable; the active wire selector and ownership remain on v4.
+ */
+export const WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE = Object.freeze({
+    ...identity,
+    coverageDigest: createHash('sha256').update(canonicalWorkspaceSyncJson(identity)).digest('hex'),
+});
+export const projectWorkspaceSyncV3WorkflowCoverageOperation = (input) => {
+    const workflow = projectWorkspaceSyncV3WorkflowRuntimeOperation(input);
+    return workflow || projectWorkspaceSyncV3NestedCoverageOperation(input);
+};
+export const WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_POLICY = Object.freeze({
+    profile: WORKSPACE_SYNC_V3_WORKFLOW_COVERAGE_PROFILE,
+    projectOperation: projectWorkspaceSyncV3WorkflowCoverageOperation,
+});
+export function validateWorkspaceSyncV3WorkflowCoverageFeedEntry(entry) {
+    if (entry.projection.startsWith('workflow-')) {
+        return validateWorkspaceSyncV3WorkflowRuntimeFeedEntry(entry);
+    }
+    return validateWorkspaceSyncV3NestedCoverageFeedEntry(entry);
+}

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

@@ -0,0 +1,17 @@
+import { WorkflowStore } from '../../storage/workflowStore.js';
+import type { WorkspaceSyncV3FeedEntry } from './workspaceSyncV3Feed.js';
+export type WorkspaceSyncV3WorkflowRuntimeApplyPlan = {
+    workflowEntries: ReadonlySet<WorkspaceSyncV3FeedEntry>;
+    executionIds: ReadonlySet<string>;
+    applyEntry: (entry: WorkspaceSyncV3FeedEntry) => void;
+};
+/**
+ * Builds complete workflow aggregates before any revision is accepted. A root
+ * entry is the atomic install trigger; definition and event entries only carry
+ * their independent revision coordinates.
+ */
+export declare function prepareWorkspaceSyncV3WorkflowRuntimeApply(input: {
+    store: WorkflowStore;
+    workspaceId: string;
+    entries: WorkspaceSyncV3FeedEntry[];
+}): WorkspaceSyncV3WorkflowRuntimeApplyPlan;