@taskforcehq/taskforce 0.3.301 → 0.3.303

package/dist/sync/taskSyncPayload.js

@@ -0,0 +1,126 @@
+function toOptionalString(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const normalized = String(value).trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function toNullableString(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    const normalized = String(value).trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function toOptionalBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function toOptionalInteger(value, options) {
+    if (value === undefined)
+        return undefined;
+    if (value === null || value === '')
+        return options?.nullable ? null : undefined;
+    const normalized = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(normalized))
+        return options?.nullable ? null : undefined;
+    const rounded = Math.floor(normalized);
+    if (Number.isFinite(options?.min) && rounded < Number(options?.min)) {
+        return options?.nullable ? null : undefined;
+    }
+    return rounded;
+}
+function cloneTaxonomies(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const entries = Object.entries(value);
+    const normalized = entries.reduce((acc, [key, raw]) => {
+        if (Array.isArray(raw)) {
+            acc[key] = raw.map((entry) => String(entry ?? ''));
+            return acc;
+        }
+        if (raw === undefined || raw === null)
+            return acc;
+        acc[key] = String(raw);
+        return acc;
+    }, {});
+    return Object.keys(normalized).length > 0 ? normalized : {};
+}
+function cloneComments(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+function cloneAttachments(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+function cloneChecklistItems(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+export function serializeTaskForSync(task) {
+    const source = task && typeof task === 'object' ? task : {};
+    return {
+        id: String(source.id || '').trim(),
+        title: String(source.title || '').trim(),
+        description: source.description === undefined ? undefined : (source.description || null),
+        status: (String(source.status || 'task').trim() || 'task'),
+        priority: toOptionalInteger(source.priority, { min: 1 }) ?? undefined,
+        complexity: toOptionalInteger(source.complexity, { min: 1, nullable: true }),
+        type: String(source.type || '').trim(),
+        category: String(source.category || '').trim(),
+        approach: toOptionalString(source.approach),
+        canceledReason: source.canceledReason === undefined ? undefined : (source.canceledReason || null),
+        createdAt: String(source.createdAt || '').trim(),
+        updatedAt: toOptionalString(source.updatedAt),
+        completedAt: source.completedAt === undefined ? undefined : (source.completedAt || null),
+        isArchived: toOptionalBoolean(source.isArchived),
+        taxonomies: cloneTaxonomies(source.taxonomies),
+        createdBy: toOptionalString(source.createdBy),
+        assignee: toOptionalString(source.assignee),
+        scheduledDate: toNullableString(source.scheduledDate),
+        dueDate: toNullableString(source.dueDate),
+        scheduledWeekKey: toNullableString(source.scheduledWeekKey),
+        orderInDay: toOptionalInteger(source.orderInDay, { min: 0, nullable: true }),
+        workstreamId: toNullableString(source.workstreamId),
+        referenceNumber: toOptionalInteger(source.referenceNumber, { min: 1, nullable: true }),
+        comments: cloneComments(source.comments),
+        attachments: cloneAttachments(source.attachments),
+        checklistItems: cloneChecklistItems(source.checklistItems),
+    };
+}
+export function normalizeTaskSyncPayload(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const id = String(source.id || '').trim();
+    if (!id)
+        return null;
+    return serializeTaskForSync(source);
+}
+export function taskSyncPayloadToCoreTask(task) {
+    return {
+        id: task.id,
+        title: task.title,
+        description: task.description,
+        status: task.status,
+        priority: task.priority,
+        complexity: task.complexity ?? undefined,
+        type: task.type,
+        category: task.category,
+        approach: task.approach,
+        canceledReason: task.canceledReason ?? undefined,
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+        completedAt: task.completedAt,
+        isArchived: task.isArchived,
+        taxonomies: task.taxonomies,
+        createdBy: task.createdBy,
+        assignee: task.assignee,
+        scheduledDate: task.scheduledDate,
+        dueDate: task.dueDate,
+        scheduledWeekKey: task.scheduledWeekKey,
+        orderInDay: task.orderInDay ?? undefined,
+        workstreamId: task.workstreamId,
+        referenceNumber: task.referenceNumber ?? undefined,
+        comments: task.comments,
+        attachments: task.attachments,
+        checklistItems: task.checklistItems
+    };
+}

package/dist/sync/taskSyncPayload.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sync/taskSyncPayload.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeTaskSyncPayload, serializeTaskForSync, taskSyncPayloadToCoreTask, } from './taskSyncPayload';
+describe('taskSyncPayload', () => {
+    it('omits local-only task reference fields from serialized sync payloads', () => {
+        const payload = serializeTaskForSync({
+            id: 'task-1',
+            title: 'Serialized task',
+            status: 'task',
+            priority: 2,
+            category: 'general',
+            type: 'task',
+            referenceNumber: 7,
+            localReferenceNumber: 3,
+            referenceLabel: 'LT-3',
+        });
+        expect(payload).toEqual(expect.objectContaining({
+            id: 'task-1',
+            referenceNumber: 7,
+        }));
+        expect(payload).not.toHaveProperty('localReferenceNumber');
+        expect(payload).not.toHaveProperty('referenceLabel');
+    });
+    it('normalizes task sync payload numbers before converting back to core input', () => {
+        const payload = normalizeTaskSyncPayload({
+            id: 'task-2',
+            title: 'Incoming task',
+            status: 'review',
+            priority: '3',
+            complexity: '4',
+            category: 'general',
+            type: 'task',
+            referenceNumber: '9',
+            orderInDay: '2',
+            localReferenceNumber: 99,
+            referenceLabel: 'LT-99',
+        });
+        expect(payload).toEqual(expect.objectContaining({
+            id: 'task-2',
+            priority: 3,
+            complexity: 4,
+            referenceNumber: 9,
+            orderInDay: 2,
+        }));
+        expect(payload).not.toHaveProperty('localReferenceNumber');
+        expect(payload).not.toHaveProperty('referenceLabel');
+        expect(taskSyncPayloadToCoreTask(payload)).toEqual(expect.objectContaining({
+            id: 'task-2',
+            priority: 3,
+            complexity: 4,
+            referenceNumber: 9,
+            orderInDay: 2,
+        }));
+    });
+});

package/dist/sync/workspacePullFeed.d.ts

@@ -0,0 +1,38 @@
+import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
+import type { WorkspaceSyncChange, WorkspaceSyncWorkspaceMemberSnapshot } from './workspaceSyncModel.js';
+import { createCollaborationSyncState } from './collaborationSyncState.js';
+import { createContentSyncState } from './contentSyncState.js';
+type SyncCore = TaskforceCore & TaskforceSyncCapable;
+export interface WorkspaceSyncCursorValue {
+    u: string;
+    id: string;
+}
+type EncodedWorkspaceSyncChange = WorkspaceSyncChange & {
+    watermark: string;
+};
+export interface WorkspacePullFeedResult {
+    workspaceMembers: WorkspaceSyncWorkspaceMemberSnapshot[];
+    changes: EncodedWorkspaceSyncChange[];
+    nextCursor: string | null;
+    hasMore: boolean;
+    diagnostics: {
+        totalEntries: number;
+        pageEntries: number;
+        documentIndexCount: number;
+        assetIndexCount: number;
+        indexMs: number;
+        hydrationMs: number;
+        encodeMs: number;
+        buildMs: number;
+    };
+}
+export declare function buildWorkspacePullFeed(input: {
+    core: SyncCore;
+    workspaceId: string;
+    cursor: WorkspaceSyncCursorValue | null;
+    pageSize: number;
+    encodeWorkspaceSyncCursor: (cursor: WorkspaceSyncCursorValue | null) => string | null;
+    contentSyncState: ReturnType<typeof createContentSyncState>;
+    collaborationSyncState: ReturnType<typeof createCollaborationSyncState>;
+}): Promise<WorkspacePullFeedResult>;
+export {};

package/dist/sync/workspacePullFeed.js

@@ -0,0 +1,349 @@
+import { serializeTaskForSync } from './taskSyncPayload.js';
+export async function buildWorkspacePullFeed(input) {
+    const buildStartedAtMs = Date.now();
+    const { core, workspaceId, cursor, pageSize, encodeWorkspaceSyncCursor, contentSyncState, collaborationSyncState } = input;
+    const syncCursor = cursor ? { watermark: cursor.u, id: cursor.id } : null;
+    const dbFetchLimit = pageSize * 2 + 10;
+    const taskRows = core.listTasksForSync(workspaceId, syncCursor, dbFetchLimit);
+    const upsertEntries = taskRows
+        .map((entry) => {
+        const watermark = String(entry.task?.updatedAt || entry.task?.createdAt || '').trim();
+        const taskId = String(entry.task?.id || '').trim();
+        return {
+            kind: 'upsert',
+            watermark,
+            sortId: taskId,
+            task: serializeTaskForSync(entry.task),
+            archived: Boolean(entry.archived)
+        };
+    })
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
+    const rawDeleteEntries = core.listWorkspaceSyncDeletesSince(workspaceId, syncCursor, dbFetchLimit);
+    const deleteEntries = rawDeleteEntries
+        .map((entry) => ({
+        kind: 'delete',
+        watermark: String(entry.deletedAt || '').trim(),
+        sortId: String(entry.taskId || '').trim(),
+        taskId: String(entry.taskId || '').trim()
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
+    const taxonomySnapshot = core.getTaxonomiesSyncSnapshot(workspaceId);
+    const taxonomyEntries = (taxonomySnapshot
+        && Array.isArray(taxonomySnapshot.taxonomies)
+        && Number.isFinite(Date.parse(String(taxonomySnapshot.updatedAt || '').trim())))
+        ? [{
+                kind: 'taxonomy',
+                watermark: String(taxonomySnapshot.updatedAt || '').trim(),
+                sortId: '__taxonomy_config__',
+                taxonomies: taxonomySnapshot.taxonomies,
+                ...(taxonomySnapshot.taxonomyState ? { taxonomyState: taxonomySnapshot.taxonomyState } : {})
+            }]
+        : [];
+    const initiativeEntries = core.listInitiatives(workspaceId)
+        .map((initiative) => ({
+        kind: 'initiative',
+        watermark: String(initiative.updatedAt || initiative.createdAt || '').trim(),
+        sortId: `initiative:${String(initiative.id || '').trim()}`,
+        initiative
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.initiative.id.length > 0);
+    const workstreamEntries = core.listWorkstreams(workspaceId)
+        .map((workstream) => ({
+        kind: 'workstream',
+        watermark: String(workstream.updatedAt || workstream.createdAt || '').trim(),
+        sortId: `workstream:${String(workstream.id || '').trim()}`,
+        workstream
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.workstream.id.length > 0);
+    const aiProfileEntries = core.listAiProfiles(workspaceId)
+        .map((profile) => ({
+        kind: 'ai-profile',
+        watermark: String(profile.updatedAt || profile.createdAt || '').trim(),
+        sortId: `ai-profile:${String(profile.id || '').trim()}`,
+        profile
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sortId.length > 0);
+    const indexStartedAtMs = Date.now();
+    const documentIndex = await contentSyncState.listWorkspaceSyncDocumentIndex(core.getPaths().basePath, workspaceId);
+    const documentEntries = documentIndex
+        .map((doc) => ({
+        kind: 'document',
+        watermark: String(doc.updatedAt || '').trim(),
+        sortId: `doc:${String(doc.path || '').trim()}`,
+        path: String(doc.path || '').trim(),
+        assetId: doc.assetId,
+        documentId: doc.documentId,
+        referenceNumber: doc.referenceNumber,
+        version: doc.version,
+        taskId: doc.taskId,
+        logicalName: doc.logicalName,
+        caption: doc.caption,
+        originalFilename: doc.originalFilename,
+        linkRole: (doc.linkRole === 'reference' ? 'reference' : 'attachment')
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
+    const documentDeleteEntries = contentSyncState.listWorkspaceSyncDocumentDeletesSnapshot(workspaceId)
+        .map((doc) => ({
+        kind: 'document-delete',
+        watermark: String(doc.deletedAt || '').trim(),
+        sortId: `doc-delete:${String(doc.path || '').trim()}:${String(doc.assetId || '').trim()}`,
+        path: String(doc.path || '').trim(),
+        assetId: typeof doc.assetId === 'string' && doc.assetId.trim().length > 0 ? doc.assetId.trim() : undefined
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
+    const documentReviewSessions = collaborationSyncState.listWorkspaceSyncDocumentReviewSessionsSnapshot(workspaceId);
+    const documentReviewSessionEntries = documentReviewSessions
+        .filter((session) => !session.deletedAt)
+        .map((session) => ({
+        kind: 'document-review-session',
+        watermark: String(session.updatedAt || session.createdAt || '').trim(),
+        sortId: `document-review-session:${String(session.id || '').trim()}`,
+        session
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.session.id.length > 0 && entry.session.assetId.length > 0);
+    const documentReviewSessionDeleteEntries = documentReviewSessions
+        .filter((session) => typeof session.deletedAt === 'string' && session.deletedAt.trim().length > 0)
+        .map((session) => ({
+        kind: 'document-review-session-delete',
+        watermark: String(session.deletedAt || session.updatedAt || '').trim(),
+        sortId: `document-review-session-delete:${String(session.id || '').trim()}`,
+        sessionId: String(session.id || '').trim()
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sessionId.length > 0);
+    const documentReviewComments = collaborationSyncState.listWorkspaceSyncDocumentReviewCommentsSnapshot(workspaceId);
+    const documentReviewCommentEntries = documentReviewComments
+        .filter((comment) => !comment.deletedAt)
+        .map((comment) => ({
+        kind: 'document-review-comment',
+        watermark: String(comment.updatedAt || comment.createdAt || '').trim(),
+        sortId: `document-review-comment:${String(comment.id || '').trim()}`,
+        comment
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.comment.id.length > 0 && entry.comment.sessionId.length > 0);
+    const documentReviewCommentDeleteEntries = documentReviewComments
+        .filter((comment) => typeof comment.deletedAt === 'string' && comment.deletedAt.trim().length > 0)
+        .map((comment) => ({
+        kind: 'document-review-comment-delete',
+        watermark: String(comment.deletedAt || comment.updatedAt || '').trim(),
+        sortId: `document-review-comment-delete:${String(comment.id || '').trim()}`,
+        commentId: String(comment.id || '').trim()
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.commentId.length > 0);
+    const annotatedAttachmentSessions = collaborationSyncState.listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(workspaceId);
+    const annotatedAttachmentSessionEntries = annotatedAttachmentSessions
+        .filter((session) => !session.deletedAt)
+        .map((session) => ({
+        kind: 'annotated-attachment-session',
+        watermark: String(session.updatedAt || session.createdAt || '').trim(),
+        sortId: `annotated-attachment-session:${String(session.id || '').trim()}`,
+        session
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.session.id.length > 0 && entry.session.baseImageAssetId.length > 0);
+    const annotatedAttachmentSessionDeleteEntries = annotatedAttachmentSessions
+        .filter((session) => typeof session.deletedAt === 'string' && session.deletedAt.trim().length > 0)
+        .map((session) => ({
+        kind: 'annotated-attachment-session-delete',
+        watermark: String(session.deletedAt || session.updatedAt || '').trim(),
+        sortId: `annotated-attachment-session-delete:${String(session.id || '').trim()}`,
+        sessionId: String(session.id || '').trim()
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.sessionId.length > 0);
+    const assetIndex = await contentSyncState.listWorkspaceSyncBinaryAssetIndex(workspaceId);
+    const assetEntries = assetIndex
+        .map((asset) => ({
+        kind: 'asset',
+        watermark: String(asset.updatedAt || '').trim(),
+        sortId: `asset:${String(asset.path || '').trim()}`,
+        path: String(asset.path || '').trim(),
+        assetId: asset.assetId,
+        kindValue: asset.kind,
+        mimeType: asset.mimeType,
+        referenceNumber: asset.referenceNumber,
+        taskId: asset.taskId,
+        logicalName: asset.logicalName,
+        caption: asset.caption,
+        originalFilename: asset.originalFilename,
+        linkRole: asset.linkRole
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
+    const assetDeleteEntries = contentSyncState.listWorkspaceSyncBinaryAssetDeletesSnapshot(workspaceId)
+        .map((asset) => ({
+        kind: 'asset-delete',
+        watermark: String(asset.deletedAt || '').trim(),
+        sortId: `asset-delete:${String(asset.path || '').trim()}:${String(asset.assetId || '').trim()}`,
+        path: String(asset.path || '').trim(),
+        assetId: typeof asset.assetId === 'string' && asset.assetId.trim().length > 0 ? asset.assetId.trim() : undefined
+    }))
+        .filter((entry) => Number.isFinite(Date.parse(entry.watermark)) && entry.path.length > 0);
+    const all = [
+        ...upsertEntries,
+        ...deleteEntries,
+        ...taxonomyEntries,
+        ...initiativeEntries,
+        ...workstreamEntries,
+        ...aiProfileEntries,
+        ...documentEntries,
+        ...documentDeleteEntries,
+        ...documentReviewSessionEntries,
+        ...documentReviewSessionDeleteEntries,
+        ...documentReviewCommentEntries,
+        ...documentReviewCommentDeleteEntries,
+        ...annotatedAttachmentSessionEntries,
+        ...annotatedAttachmentSessionDeleteEntries,
+        ...assetEntries,
+        ...assetDeleteEntries
+    ];
+    const afterCursor = all.filter((entry) => {
+        if (!cursor)
+            return true;
+        if (entry.watermark > cursor.u)
+            return true;
+        if (entry.watermark < cursor.u)
+            return false;
+        return entry.sortId > cursor.id;
+    });
+    afterCursor.sort((a, b) => {
+        if (a.watermark !== b.watermark)
+            return a.watermark.localeCompare(b.watermark);
+        return String(a.sortId || '').localeCompare(String(b.sortId || ''));
+    });
+    const page = afterCursor.slice(0, pageSize);
+    const workspaceMembers = core.listWorkspaceUsers(workspaceId).map((member) => ({
+        userId: member.userId,
+        workspaceId,
+        email: member.email,
+        displayName: member.displayName || null,
+        role: member.role,
+        permissionMode: member.permissionMode,
+        betaAccess: member.betaAccess,
+        status: member.status,
+        disabled: member.disabled,
+        createdAt: member.createdAt || null,
+        updatedAt: member.updatedAt || null,
+        emailVerifiedAt: member.emailVerifiedAt || null
+    }));
+    const indexMs = Date.now() - indexStartedAtMs;
+    const hydratedDocuments = new Map();
+    const hydratedAssets = new Map();
+    const hydrationStartedAtMs = Date.now();
+    await Promise.all(page.map(async (entry) => {
+        if (entry.kind === 'document') {
+            const payload = await contentSyncState.loadWorkspaceSyncDocumentPayload(core.getPaths().basePath, workspaceId, entry.path);
+            hydratedDocuments.set(entry.path, payload);
+            return;
+        }
+        if (entry.kind === 'asset') {
+            const payload = await contentSyncState.loadWorkspaceSyncBinaryAssetPayload(core.getPaths().basePath, workspaceId, entry.path);
+            hydratedAssets.set(entry.path, payload);
+        }
+    }));
+    const hydrationMs = Date.now() - hydrationStartedAtMs;
+    const effectivePage = [];
+    for (const entry of page) {
+        if (entry.kind === 'document' && !hydratedDocuments.get(entry.path))
+            break;
+        if (entry.kind === 'asset' && !hydratedAssets.get(entry.path))
+            break;
+        effectivePage.push(entry);
+    }
+    const hasMore = afterCursor.length > effectivePage.length;
+    const last = effectivePage.length > 0 ? effectivePage[effectivePage.length - 1] : null;
+    const nextCursor = encodeWorkspaceSyncCursor(last
+        ? { u: last.watermark, id: String(last.sortId || '') }
+        : cursor);
+    const encodeStartedAtMs = Date.now();
+    const changes = effectivePage.flatMap((entry) => (entry.kind === 'delete'
+        ? [{ op: 'delete', taskId: entry.taskId, watermark: entry.watermark }]
+        : entry.kind === 'taxonomy'
+            ? [{
+                    op: 'taxonomy-upsert',
+                    taxonomies: entry.taxonomies,
+                    ...(entry.taxonomyState ? { taxonomyState: entry.taxonomyState } : {}),
+                    updatedAt: entry.watermark,
+                    watermark: entry.watermark
+                }]
+            : entry.kind === 'initiative'
+                ? [{ op: 'initiative-upsert', initiative: entry.initiative, watermark: entry.watermark }]
+                : entry.kind === 'workstream'
+                    ? [{ op: 'workstream-upsert', workstream: entry.workstream, watermark: entry.watermark }]
+                    : entry.kind === 'ai-profile'
+                        ? [{ op: 'ai-profile-upsert', profile: entry.profile, watermark: entry.watermark }]
+                        : entry.kind === 'document-review-session'
+                            ? [{ op: 'document-review-session-upsert', session: entry.session, watermark: entry.watermark }]
+                            : entry.kind === 'document-review-session-delete'
+                                ? [{ op: 'document-review-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                : entry.kind === 'document-review-comment'
+                                    ? [{ op: 'document-review-comment-upsert', comment: entry.comment, watermark: entry.watermark }]
+                                    : entry.kind === 'document-review-comment-delete'
+                                        ? [{ op: 'document-review-comment-delete', commentId: entry.commentId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                        : entry.kind === 'annotated-attachment-session'
+                                            ? [{ op: 'annotated-attachment-session-upsert', session: entry.session, watermark: entry.watermark }]
+                                            : entry.kind === 'annotated-attachment-session-delete'
+                                                ? [{ op: 'annotated-attachment-session-delete', sessionId: entry.sessionId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                                : entry.kind === 'document'
+                                                    ? (() => {
+                                                        const payload = hydratedDocuments.get(entry.path);
+                                                        if (!payload)
+                                                            return [];
+                                                        return [{
+                                                                op: 'document-upsert',
+                                                                path: entry.path,
+                                                                updatedAt: entry.watermark,
+                                                                content: payload.content,
+                                                                assetId: payload.assetId,
+                                                                documentId: payload.documentId,
+                                                                referenceNumber: payload.referenceNumber,
+                                                                version: payload.version,
+                                                                taskId: payload.taskId,
+                                                                logicalName: payload.logicalName,
+                                                                caption: payload.caption,
+                                                                originalFilename: payload.originalFilename,
+                                                                linkRole: payload.linkRole === 'reference' ? 'reference' : 'attachment',
+                                                                watermark: entry.watermark
+                                                            }];
+                                                    })()
+                                                    : entry.kind === 'document-delete'
+                                                        ? [{ op: 'document-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                                        : entry.kind === 'asset'
+                                                            ? (() => {
+                                                                const payload = hydratedAssets.get(entry.path);
+                                                                if (!payload)
+                                                                    return [];
+                                                                return [{
+                                                                        op: 'asset-upsert',
+                                                                        path: entry.path,
+                                                                        updatedAt: entry.watermark,
+                                                                        contentBase64: payload.contentBase64,
+                                                                        assetId: payload.assetId,
+                                                                        kind: payload.kind,
+                                                                        mimeType: payload.mimeType,
+                                                                        referenceNumber: payload.referenceNumber,
+                                                                        taskId: payload.taskId,
+                                                                        logicalName: payload.logicalName,
+                                                                        caption: payload.caption,
+                                                                        originalFilename: payload.originalFilename,
+                                                                        linkRole: payload.linkRole,
+                                                                        watermark: entry.watermark
+                                                                    }];
+                                                            })()
+                                                            : entry.kind === 'asset-delete'
+                                                                ? [{ op: 'asset-delete', path: entry.path, assetId: entry.assetId, deletedAt: entry.watermark, watermark: entry.watermark }]
+                                                                : [{ op: 'upsert', task: entry.task, archived: Boolean(entry.archived), watermark: entry.watermark }]));
+    const encodeMs = Date.now() - encodeStartedAtMs;
+    return {
+        workspaceMembers,
+        changes,
+        nextCursor,
+        hasMore,
+        diagnostics: {
+            totalEntries: all.length,
+            pageEntries: page.length,
+            documentIndexCount: documentIndex.length,
+            assetIndexCount: assetIndex.length,
+            indexMs,
+            hydrationMs,
+            encodeMs,
+            buildMs: Date.now() - buildStartedAtMs
+        }
+    };
+}

package/dist/sync/workspacePullFeed.test.d.ts

@@ -0,0 +1 @@
+export {};