@taskforcehq/taskforce 0.3.168

package/dist/sync/syncService.test.js

@@ -0,0 +1,484 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { runWorkspacePullSyncService, runWorkspacePushSyncService, ensureCloudWorkspaceReadyForSyncService, syncUserGlobalSettingsService } from './syncService';
+vi.mock('./cloudSyncApi', () => ({
+    pullWorkspaceChanges: vi.fn(),
+    pushWorkspaceChanges: vi.fn(),
+    applyLocalWorkspaceChanges: vi.fn(),
+    handshakeWorkspace: vi.fn(),
+    provisionWorkspace: vi.fn(),
+    pullUserSettings: vi.fn(),
+    pushUserSettings: vi.fn()
+}));
+import { pullWorkspaceChanges, pushWorkspaceChanges, applyLocalWorkspaceChanges, handshakeWorkspace, pullUserSettings, pushUserSettings } from './cloudSyncApi';
+const mockResolveCloudAuthUrl = (p) => p;
+const baseHandshakeInput = {
+    cloudAuthConfigured: true,
+    runtimeMode: 'local',
+    isAuthenticated: true,
+    resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+    workspaceId: 'ws-test',
+    workspaceName: 'Test Workspace'
+};
+describe('syncService', () => {
+    describe('runWorkspacePushSyncService', () => {
+        beforeEach(() => {
+            vi.mocked(pushWorkspaceChanges).mockReset();
+        });
+        it('returns current/delete document path sets from payload', async () => {
+            vi.mocked(pushWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: { success: true, emittedEventIds: ['epoch-1:1', 'epoch-1:1', 'epoch-1:2', ''] }
+            });
+            const result = await runWorkspacePushSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                payload: {
+                    changes: [{ op: 'document-delete', path: 'docs/remove.md' }],
+                    currentTaskIds: new Set(['task-1']),
+                    deleteTaskIds: new Set(),
+                    currentDocumentPaths: new Set(['docs/keep.md']),
+                    deleteDocumentPaths: new Set(['docs/remove.md']),
+                    currentDocumentWatermarks: new Map([['docs/keep.md', '2026-02-01T00:00:00.000Z']]),
+                    pushedWatermarks: new Map([['task-1', 'wm-1']])
+                },
+                ensureCloudWorkspaceReadyForSync: async () => ({ success: true })
+            });
+            expect(result.success).toBe(true);
+            expect(Array.from(result.currentDocumentPaths)).toEqual(['docs/keep.md']);
+            expect(Array.from(result.deleteDocumentPaths)).toEqual(['docs/remove.md']);
+            expect(result.changeCount).toBe(1);
+            expect(result.emittedEventIds).toEqual(['epoch-1:1', 'epoch-1:2']);
+        });
+        it('uses deterministic fallback idempotency key when crypto.subtle is unavailable', async () => {
+            const payload = {
+                changes: [{ op: 'document-delete', path: 'docs/remove.md' }],
+                currentTaskIds: new Set(),
+                deleteTaskIds: new Set(),
+                currentDocumentPaths: new Set(),
+                deleteDocumentPaths: new Set(['docs/remove.md']),
+                currentDocumentWatermarks: new Map(),
+                pushedWatermarks: new Map()
+            };
+            vi.mocked(pushWorkspaceChanges)
+                .mockResolvedValue({
+                ok: true,
+                status: 200,
+                data: { success: true }
+            });
+            vi.stubGlobal('crypto', {});
+            try {
+                await runWorkspacePushSyncService({
+                    resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                    workspaceId: 'ws-fallback',
+                    payload,
+                    ensureCloudWorkspaceReadyForSync: async () => ({ success: true })
+                });
+                await runWorkspacePushSyncService({
+                    resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                    workspaceId: 'ws-fallback',
+                    payload,
+                    ensureCloudWorkspaceReadyForSync: async () => ({ success: true })
+                });
+            }
+            finally {
+                vi.unstubAllGlobals();
+            }
+            expect(pushWorkspaceChanges).toHaveBeenCalledTimes(2);
+            const firstKey = vi.mocked(pushWorkspaceChanges).mock.calls[0]?.[1]?.idempotencyKey;
+            const secondKey = vi.mocked(pushWorkspaceChanges).mock.calls[1]?.[1]?.idempotencyKey;
+            expect(firstKey).toEqual(secondKey);
+            expect(String(firstKey || '')).toMatch(/^ws-fallback:fallback:[0-9a-f]{8}$/);
+        });
+        it('reuses the same idempotency key when retrying push after ensure succeeds', async () => {
+            vi.mocked(pushWorkspaceChanges)
+                .mockResolvedValueOnce({
+                ok: false,
+                status: 403,
+                data: { error: 'forbidden' }
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: { success: true }
+            });
+            const ensureCloudWorkspaceReadyForSync = vi.fn().mockResolvedValue({ success: true });
+            const result = await runWorkspacePushSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-retry',
+                payload: {
+                    changes: [{ op: 'delete', taskId: 'task-1' }],
+                    currentTaskIds: new Set(),
+                    deleteTaskIds: new Set(['task-1']),
+                    currentDocumentPaths: new Set(),
+                    deleteDocumentPaths: new Set(),
+                    currentDocumentWatermarks: new Map(),
+                    pushedWatermarks: new Map()
+                },
+                ensureCloudWorkspaceReadyForSync
+            });
+            expect(result.success).toBe(true);
+            expect(ensureCloudWorkspaceReadyForSync).toHaveBeenCalledTimes(1);
+            expect(pushWorkspaceChanges).toHaveBeenCalledTimes(2);
+            const firstKey = vi.mocked(pushWorkspaceChanges).mock.calls[0]?.[1]?.idempotencyKey;
+            const secondKey = vi.mocked(pushWorkspaceChanges).mock.calls[1]?.[1]?.idempotencyKey;
+            expect(firstKey).toEqual(secondKey);
+        });
+        it('surfaces push error details from non-ok cloud responses', async () => {
+            vi.mocked(pushWorkspaceChanges).mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                data: {
+                    error: 'Failed to apply workspace deltas',
+                    code: 'SQLITE_BUSY'
+                }
+            });
+            const result = await runWorkspacePushSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-error',
+                payload: {
+                    changes: [{ op: 'delete', taskId: 'task-1' }],
+                    currentTaskIds: new Set(),
+                    deleteTaskIds: new Set(['task-1']),
+                    currentDocumentPaths: new Set(),
+                    deleteDocumentPaths: new Set(),
+                    currentDocumentWatermarks: new Map(),
+                    pushedWatermarks: new Map()
+                },
+                ensureCloudWorkspaceReadyForSync: async () => ({ success: false })
+            });
+            expect(result.success).toBe(false);
+            expect(result.status).toBe(500);
+            expect(result.error).toBe('Failed to apply workspace deltas');
+            expect(result.code).toBe('SQLITE_BUSY');
+        });
+    });
+    describe('runWorkspacePullSyncService', () => {
+        beforeEach(() => {
+            vi.mocked(pullWorkspaceChanges).mockReset();
+            vi.mocked(applyLocalWorkspaceChanges).mockReset();
+        });
+        it('halts pagination correctly when hasMore is false', async () => {
+            vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: {
+                    success: true,
+                    changes: [],
+                    nextCursor: null,
+                    hasMore: false
+                }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false
+            });
+            expect(pullWorkspaceChanges).toHaveBeenCalledTimes(1);
+            expect(res.cursor).toBeNull();
+            expect(res.success).toBe(true);
+        });
+        it('correctly advances cursor across multiple pages', async () => {
+            vi.mocked(pullWorkspaceChanges)
+                .mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    success: true,
+                    changes: [],
+                    nextCursor: 'page-2-cursor',
+                    hasMore: true
+                }
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                data: {
+                    success: true,
+                    changes: [],
+                    nextCursor: null,
+                    hasMore: false
+                }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false
+            });
+            expect(pullWorkspaceChanges).toHaveBeenCalledTimes(2);
+            expect(res.cursor).toBeNull();
+            expect(res.success).toBe(true);
+        });
+        it('surfaces retryAfterMs when cloud returns 429', async () => {
+            vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
+                ok: false,
+                status: 429,
+                retryAfterMs: 30_000,
+                data: { error: 'Rate limited' }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false
+            });
+            expect(res.success).toBe(false);
+            expect(res.kind).toBe('pull_http');
+            expect(res.status).toBe(429);
+            expect(res.retryAfterMs).toBe(30_000);
+        });
+        it('retries pull once after 403 when ensure succeeds', async () => {
+            const ensureCloudWorkspaceReadyForSync = vi.fn().mockResolvedValue({ success: true });
+            vi.mocked(pullWorkspaceChanges)
+                .mockResolvedValueOnce({
+                ok: false,
+                status: 403,
+                data: { error: 'Forbidden' }
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: {
+                    success: true,
+                    changes: [],
+                    nextCursor: null,
+                    hasMore: false
+                }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false,
+                ensureCloudWorkspaceReadyForSync
+            });
+            expect(res.success).toBe(true);
+            expect(ensureCloudWorkspaceReadyForSync).toHaveBeenCalledTimes(1);
+            expect(pullWorkspaceChanges).toHaveBeenCalledTimes(2);
+        });
+        it('does not retry pull when ensure after 403 fails', async () => {
+            const ensureCloudWorkspaceReadyForSync = vi.fn().mockResolvedValue({ success: false, statusCode: 403 });
+            vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
+                ok: false,
+                status: 403,
+                data: { error: 'Forbidden' }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false,
+                ensureCloudWorkspaceReadyForSync
+            });
+            expect(res.success).toBe(false);
+            expect(res.kind).toBe('pull_http');
+            expect(res.status).toBe(403);
+            expect(ensureCloudWorkspaceReadyForSync).toHaveBeenCalledTimes(1);
+            expect(pullWorkspaceChanges).toHaveBeenCalledTimes(1);
+        });
+        it('returns pull_http kind with status 401 on auth failure', async () => {
+            vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
+                ok: false,
+                status: 401,
+                data: { error: 'Unauthorized' }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false
+            });
+            expect(res.success).toBe(false);
+            expect(res.kind).toBe('pull_http');
+            expect(res.status).toBe(401);
+        });
+        it('returns apply_auth kind when apply-local returns 401', async () => {
+            vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: {
+                    success: true,
+                    changes: [{ op: 'upsert', task: { id: 't1', title: 'Task 1', updatedAt: '2026-01-01T00:00:00Z' } }],
+                    nextCursor: null,
+                    hasMore: false
+                }
+            });
+            vi.mocked(applyLocalWorkspaceChanges).mockResolvedValueOnce({
+                ok: false,
+                failures: ['apply:401'],
+                appliedCount: 0
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false
+            });
+            expect(res.success).toBe(false);
+            expect(res.kind).toBe('apply_auth');
+            expect(res.status).toBe(401);
+        });
+        it('surfaces document decryption failures without failing pull', async () => {
+            const previousKey = process.env.TASKFORCE_SYNC_KEY;
+            process.env.TASKFORCE_SYNC_KEY = 'test-sync-key';
+            vi.mocked(pullWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: {
+                    success: true,
+                    changes: [{ op: 'document-upsert', path: 'docs/secret.md', content: 'V1:AESGCM:malformed' }],
+                    nextCursor: null,
+                    hasMore: false
+                }
+            });
+            vi.mocked(applyLocalWorkspaceChanges).mockResolvedValueOnce({
+                ok: true,
+                failures: [],
+                appliedCount: 1,
+                data: { success: true }
+            });
+            try {
+                const res = await runWorkspacePullSyncService({
+                    resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                    workspaceId: 'ws-1',
+                    cursor: null,
+                    bootstrap: false
+                });
+                expect(res.success).toBe(true);
+                expect(res.documentDecryptFailures).toEqual(['docs/secret.md']);
+            }
+            finally {
+                if (typeof previousKey === 'string')
+                    process.env.TASKFORCE_SYNC_KEY = previousKey;
+                else
+                    delete process.env.TASKFORCE_SYNC_KEY;
+            }
+        });
+        it('stops at maxPages and returns partial success', async () => {
+            // Always returns hasMore=true so the loop would run forever without maxPages
+            vi.mocked(pullWorkspaceChanges).mockResolvedValue({
+                ok: true,
+                data: {
+                    success: true,
+                    changes: [],
+                    nextCursor: 'cursor-next',
+                    hasMore: true
+                }
+            });
+            const res = await runWorkspacePullSyncService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                workspaceId: 'ws-1',
+                cursor: null,
+                bootstrap: false,
+                maxPages: 3
+            });
+            expect(pullWorkspaceChanges).toHaveBeenCalledTimes(3);
+            expect(res.success).toBe(true);
+            expect(res.pages).toBe(3);
+        });
+    });
+    describe('ensureCloudWorkspaceReadyForSyncService', () => {
+        beforeEach(() => {
+            vi.mocked(handshakeWorkspace).mockReset();
+        });
+        it('returns success when handshake succeeds', async () => {
+            vi.mocked(handshakeWorkspace).mockResolvedValueOnce({
+                ok: true, status: 200, data: {}
+            });
+            const res = await ensureCloudWorkspaceReadyForSyncService(baseHandshakeInput);
+            expect(res.success).toBe(true);
+            expect(res.provisioned).toBe(false);
+        });
+        it('propagates 401 from handshake as auth failure', async () => {
+            vi.mocked(handshakeWorkspace).mockResolvedValueOnce({
+                ok: false, status: 401, data: { error: 'Invalid session' }
+            });
+            const res = await ensureCloudWorkspaceReadyForSyncService(baseHandshakeInput);
+            expect(res.success).toBe(false);
+            expect(res.statusCode).toBe(401);
+            expect(res.error).toContain('Invalid session');
+        });
+        it('propagates 429 from handshake with retryAfterMs', async () => {
+            vi.mocked(handshakeWorkspace).mockResolvedValueOnce({
+                ok: false, status: 429, retryAfterMs: 45_000, data: { error: 'Rate limited' }
+            });
+            const res = await ensureCloudWorkspaceReadyForSyncService(baseHandshakeInput);
+            expect(res.success).toBe(false);
+            expect(res.statusCode).toBe(429);
+            expect(res.retryAfterMs).toBe(45_000);
+        });
+        it('returns failure when cloudAuthConfigured is false', async () => {
+            const res = await ensureCloudWorkspaceReadyForSyncService({
+                ...baseHandshakeInput,
+                cloudAuthConfigured: false
+            });
+            expect(res.success).toBe(false);
+            expect(handshakeWorkspace).not.toHaveBeenCalled();
+        });
+        it('returns failure when runtimeMode is not local', async () => {
+            const res = await ensureCloudWorkspaceReadyForSyncService({
+                ...baseHandshakeInput,
+                runtimeMode: 'cloud'
+            });
+            expect(res.success).toBe(false);
+            expect(handshakeWorkspace).not.toHaveBeenCalled();
+        });
+        it('returns failure when not authenticated', async () => {
+            const res = await ensureCloudWorkspaceReadyForSyncService({
+                ...baseHandshakeInput,
+                isAuthenticated: false
+            });
+            expect(res.success).toBe(false);
+            expect(handshakeWorkspace).not.toHaveBeenCalled();
+        });
+    });
+    describe('syncUserGlobalSettingsService transient metadata', () => {
+        beforeEach(() => {
+            vi.mocked(pullUserSettings).mockReset();
+            vi.mocked(pushUserSettings).mockReset();
+        });
+        it('propagates retryAfterMs + transient for pull 429 failure', async () => {
+            vi.mocked(pullUserSettings).mockResolvedValueOnce({
+                ok: false,
+                status: 429,
+                retryAfterMs: 30_000,
+                data: { error: 'Rate limited' }
+            });
+            const res = await syncUserGlobalSettingsService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                userId: 'user-1',
+                preferCloudOnFirstSync: true,
+                getLocalUpdatedAt: () => null,
+                buildLocalSettings: () => ({ theme: 'dark' }),
+                applyRemoteSettings: async () => { }
+            });
+            expect(res.success).toBe(false);
+            expect(res.statusCode).toBe(429);
+            expect(res.retryAfterMs).toBe(30_000);
+            expect(res.transient).toBe(true);
+        });
+        it('propagates transient=true for push status 0 failure', async () => {
+            vi.mocked(pullUserSettings).mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                data: { settings: {}, updatedAt: null }
+            });
+            vi.mocked(pushUserSettings).mockResolvedValueOnce({
+                ok: false,
+                status: 0,
+                data: {}
+            });
+            const res = await syncUserGlobalSettingsService({
+                resolveCloudAuthUrl: mockResolveCloudAuthUrl,
+                userId: 'user-1',
+                preferCloudOnFirstSync: false,
+                getLocalUpdatedAt: () => null,
+                buildLocalSettings: () => ({ theme: 'dark' }),
+                applyRemoteSettings: async () => { }
+            });
+            expect(res.success).toBe(false);
+            expect(res.statusCode).toBe(0);
+            expect(res.transient).toBe(true);
+        });
+    });
+});

package/dist/sync/workspaceSyncModel.d.ts

@@ -0,0 +1,61 @@
+import type { TaskItem } from '../types';
+export type WorkspaceSyncChange = {
+    op: 'upsert';
+    archived: boolean;
+    task: TaskItem;
+} | {
+    op: 'delete';
+    taskId: string;
+} | {
+    op: 'taxonomy-upsert';
+    taxonomies: unknown[];
+    updatedAt: string;
+} | {
+    op: 'document-upsert';
+    path: string;
+    updatedAt: string;
+    content: string;
+} | {
+    op: 'document-delete';
+    path: string;
+};
+export interface WorkspaceSyncPayload {
+    changes: WorkspaceSyncChange[];
+    currentTaskIds: Set<string>;
+    deleteTaskIds: Set<string>;
+    currentDocumentPaths: Set<string>;
+    deleteDocumentPaths: Set<string>;
+    currentDocumentWatermarks: Map<string, string>;
+    /** Watermarks for every task upsert included in this payload (id → updatedAt|createdAt). */
+    pushedWatermarks: Map<string, string>;
+}
+export interface WorkspaceSyncDocumentSnapshot {
+    path: string;
+    updatedAt: string;
+    content: string;
+}
+export declare function buildWorkspaceSyncPayloadModel(input: {
+    tasks: TaskItem[];
+    archivedTasks: TaskItem[];
+    lastPushedTaskIds: Set<string>;
+    pendingDeletedTaskIds: Set<string>;
+    taxonomies?: unknown[];
+    documents?: WorkspaceSyncDocumentSnapshot[];
+    lastPushedDocumentPaths?: Set<string>;
+    lastPushedDocumentWatermarks?: Map<string, string>;
+    /**
+     * Watermark (updatedAt|createdAt) of each task as of its last successful push.
+     * When provided, only tasks whose watermark differs from this map are included
+     * in the upsert changes — reducing payload size from O(n) to O(changed).
+     * Absent or empty map = include all tasks (first-push / full-sync behaviour).
+     */
+    lastPushedWatermarks?: Map<string, string>;
+}): WorkspaceSyncPayload;
+export declare function buildWorkspaceSyncSignatureModel(input: {
+    workspaceId: string;
+    tasks: TaskItem[];
+    archivedTasks: TaskItem[];
+    pendingDeletedTaskIds?: Set<string>;
+    taxonomies?: unknown[];
+    documents?: WorkspaceSyncDocumentSnapshot[];
+}): string;

package/dist/sync/workspaceSyncModel.js

@@ -0,0 +1,136 @@
+export function buildWorkspaceSyncPayloadModel(input) {
+    const payloadBuiltAt = new Date().toISOString();
+    const pendingDeleteIds = new Set(Array.from(input.pendingDeletedTaskIds)
+        .map((taskId) => String(taskId || '').trim())
+        .filter((taskId) => taskId.length > 0));
+    const lastWatermarks = input.lastPushedWatermarks;
+    const isDirty = (task) => {
+        if (!lastWatermarks || lastWatermarks.size === 0)
+            return true;
+        const taskId = String(task?.id || '').trim();
+        if (!taskId)
+            return false;
+        const currentWatermark = String(task?.updatedAt || task?.createdAt || '').trim();
+        return lastWatermarks.get(taskId) !== currentWatermark;
+    };
+    const pushedWatermarks = new Map();
+    const activeChanges = (input.tasks || [])
+        .filter((task) => !pendingDeleteIds.has(String(task?.id || '').trim()) && isDirty(task))
+        .map((task) => {
+        const taskId = String(task?.id || '').trim();
+        const wm = String(task?.updatedAt || task?.createdAt || '').trim();
+        if (taskId)
+            pushedWatermarks.set(taskId, wm);
+        return { op: 'upsert', archived: false, task };
+    });
+    const archivedChanges = (input.archivedTasks || [])
+        .filter((task) => !pendingDeleteIds.has(String(task?.id || '').trim()) && isDirty(task))
+        .map((task) => {
+        const taskId = String(task?.id || '').trim();
+        const wm = String(task?.updatedAt || task?.createdAt || '').trim();
+        if (taskId)
+            pushedWatermarks.set(taskId, wm);
+        return { op: 'upsert', archived: true, task };
+    });
+    const currentTaskIds = new Set();
+    for (const task of input.tasks || []) {
+        const taskId = String(task?.id || '').trim();
+        if (taskId)
+            currentTaskIds.add(taskId);
+    }
+    for (const task of input.archivedTasks || []) {
+        const taskId = String(task?.id || '').trim();
+        if (taskId)
+            currentTaskIds.add(taskId);
+    }
+    const deleteChanges = Array.from(input.lastPushedTaskIds)
+        .filter((taskId) => !currentTaskIds.has(taskId))
+        .map((taskId) => ({
+        op: 'delete',
+        taskId
+    }));
+    const queuedDeleteChanges = Array.from(pendingDeleteIds)
+        .map((taskId) => ({
+        op: 'delete',
+        taskId
+    }));
+    const deleteTaskIds = new Set([
+        ...deleteChanges.map((change) => String(change.taskId)),
+        ...queuedDeleteChanges.map((change) => String(change.taskId))
+    ]);
+    const currentDocumentPaths = new Set((Array.isArray(input.documents) ? input.documents : [])
+        .map((doc) => String(doc?.path || '').trim())
+        .filter((docPath) => docPath.length > 0));
+    const deleteDocumentPaths = new Set(Array.from(input.lastPushedDocumentPaths || new Set())
+        .map((docPath) => String(docPath || '').trim())
+        .filter((docPath) => docPath.length > 0 && !currentDocumentPaths.has(docPath)));
+    const currentDocumentWatermarks = new Map((Array.isArray(input.documents) ? input.documents : [])
+        .map((doc) => [String(doc?.path || '').trim(), String(doc?.updatedAt || '').trim()])
+        .filter(([docPath]) => docPath.length > 0));
+    const previousDocumentWatermarks = input.lastPushedDocumentWatermarks;
+    const shouldSendAllDocuments = !previousDocumentWatermarks || previousDocumentWatermarks.size === 0;
+    const documentUpsertChanges = (Array.isArray(input.documents) ? input.documents : [])
+        .map((doc) => ({
+        op: 'document-upsert',
+        path: String(doc.path || '').trim(),
+        updatedAt: String(doc.updatedAt || '').trim(),
+        content: typeof doc.content === 'string' ? doc.content : ''
+    }))
+        .filter((doc) => doc.path.length > 0)
+        .filter((doc) => {
+        if (shouldSendAllDocuments)
+            return true;
+        return previousDocumentWatermarks.get(doc.path) !== doc.updatedAt;
+    });
+    return {
+        changes: [
+            ...(Array.isArray(input.taxonomies)
+                ? [{
+                        op: 'taxonomy-upsert',
+                        taxonomies: input.taxonomies,
+                        updatedAt: payloadBuiltAt
+                    }]
+                : []),
+            ...documentUpsertChanges,
+            ...Array.from(deleteDocumentPaths).map((docPath) => ({
+                op: 'document-delete',
+                path: docPath
+            })),
+            ...activeChanges,
+            ...archivedChanges,
+            ...Array.from(deleteTaskIds).map((taskId) => ({ op: 'delete', taskId }))
+        ],
+        currentTaskIds: new Set(Array.from(currentTaskIds).filter((taskId) => !pendingDeleteIds.has(taskId))),
+        deleteTaskIds,
+        currentDocumentPaths,
+        deleteDocumentPaths,
+        currentDocumentWatermarks,
+        pushedWatermarks
+    };
+}
+export function buildWorkspaceSyncSignatureModel(input) {
+    const active = (input.tasks || [])
+        .map((task) => `${task.id}:${task.updatedAt || task.createdAt || ''}:${task.status}:${task.parentTaskId || ''}`)
+        .sort();
+    const archived = (input.archivedTasks || [])
+        .map((task) => `${task.id}:${task.updatedAt || task.createdAt || ''}:${task.status}:${task.parentTaskId || ''}`)
+        .sort();
+    const pendingDeletes = input.pendingDeletedTaskIds ? Array.from(input.pendingDeletedTaskIds).sort() : [];
+    return JSON.stringify({
+        workspaceId: input.workspaceId,
+        taxonomies: Array.isArray(input.taxonomies) ? input.taxonomies : [],
+        documents: Array.isArray(input.documents)
+            ? input.documents
+                .map((doc) => ({
+                path: String(doc.path || '').trim(),
+                updatedAt: String(doc.updatedAt || '').trim(),
+                length: typeof doc.content === 'string' ? doc.content.length : 0
+            }))
+                .filter((doc) => doc.path.length > 0)
+                .sort((a, b) => a.path.localeCompare(b.path))
+            : [],
+        active,
+        archived,
+        pendingDeletes
+    });
+}

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

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