@taskforcehq/taskforce 0.3.301 → 0.3.303

package/dist/shared/runtimeContract.d.ts

@@ -1,5 +1,5 @@
 export type RuntimeMode = 'local' | 'cloud';
-export type AuthSource = 'cloud' | 'local';
+export type AuthSource = 'cloud';
 export type WorkspaceMode = 'single-local' | 'multi-cloud';
 export interface RuntimeModeContract {
     runtimeMode: RuntimeMode;

package/dist/sync/cloudSyncApi.d.ts

@@ -25,6 +25,7 @@ export declare function pullWorkspaceChanges(resolveCloudAuthUrl: (path: string)
     nextCursor?: string | null;
     hasMore?: boolean;
     workspaceMembers?: WorkspaceSyncWorkspaceMemberSnapshot[];
+    diagnostics?: Record<string, unknown>;
 }>>;
 export declare function pushWorkspaceChanges(resolveCloudAuthUrl: (path: string) => string, input: {
     workspaceId: string;

package/dist/sync/collaborationSyncPayload.d.ts

@@ -0,0 +1,17 @@
+import type { WorkspaceSyncAiProfileSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot } from './workspaceSyncModel.js';
+import type { AiProfileSurfaceType } from '../shared/aiProfileSurfaceType.js';
+export declare function normalizeAiProfileSyncPayload(raw: unknown, workspaceId: string, normalizeSurfaceType: (value: unknown, context: {
+    source: string;
+    profileId?: string;
+    workspaceId?: string;
+}) => AiProfileSurfaceType | null, source: string): WorkspaceSyncAiProfileSnapshot | null;
+export declare function normalizeDocumentReviewSessionSyncPayload(raw: unknown, sourceWatermark?: string): WorkspaceSyncDocumentReviewSessionSnapshot | null;
+export declare function normalizeDocumentReviewCommentSyncPayload(raw: unknown, options?: {
+    sessionId?: string;
+    sourceWatermark?: string;
+}): WorkspaceSyncDocumentReviewCommentSnapshot | null;
+export declare function normalizeAnnotatedAttachmentSessionSyncPayload(raw: unknown, expectedWorkspaceId?: string, sourceWatermark?: string): WorkspaceSyncAnnotatedAttachmentSessionSnapshot | null;
+export declare function normalizeDeleteSyncPayload(raw: unknown, idKey: 'sessionId' | 'commentId'): {
+    id: string;
+    deletedAt: string;
+} | null;

package/dist/sync/collaborationSyncPayload.js

@@ -0,0 +1,131 @@
+function toOptionalTrimmedString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function toNullableTrimmedString(value) {
+    return toOptionalTrimmedString(value) ?? null;
+}
+function toOptionalPositiveInteger(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const normalized = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(normalized))
+        return null;
+    return Math.max(1, Math.floor(normalized));
+}
+function toOptionalNonNegativeInteger(value) {
+    if (value === undefined || value === null || value === '')
+        return 0;
+    const normalized = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(normalized))
+        return 0;
+    return Math.max(0, Math.floor(normalized));
+}
+export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurfaceType, source) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const profile = raw;
+    const profileId = String(profile.id || '').trim();
+    if (!profileId)
+        return null;
+    const profileWorkspaceId = String(profile.workspaceId || workspaceId).trim() || workspaceId;
+    return {
+        id: profileId,
+        workspaceId: profileWorkspaceId,
+        profileToken: String(profile.profileToken || '').trim(),
+        name: String(profile.name || '').trim(),
+        username: String(profile.username || '').trim(),
+        icon: String(profile.icon || 'Bot').trim() || 'Bot',
+        color: String(profile.color || '#8b5cf6').trim() || '#8b5cf6',
+        surfaceType: normalizeSurfaceType(profile.surfaceType, { source, profileId, workspaceId: profileWorkspaceId }),
+        providerMetadata: profile.providerMetadata && typeof profile.providerMetadata === 'object' && !Array.isArray(profile.providerMetadata)
+            ? profile.providerMetadata
+            : null,
+        createdAt: String(profile.createdAt || '').trim(),
+        updatedAt: String(profile.updatedAt || profile.createdAt || '').trim(),
+        lastActiveAt: toNullableTrimmedString(profile.lastActiveAt),
+    };
+}
+export function normalizeDocumentReviewSessionSyncPayload(raw, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const session = raw;
+    const id = String(session.id || '').trim();
+    const assetId = String(session.assetId || '').trim();
+    if (!id || !assetId)
+        return null;
+    return {
+        id,
+        assetId,
+        documentId: toNullableTrimmedString(session.documentId),
+        documentVersion: toOptionalPositiveInteger(session.documentVersion),
+        title: toNullableTrimmedString(session.title),
+        status: session.status === 'resolved' ? 'resolved' : 'open',
+        comments: Array.isArray(session.comments) ? session.comments : [],
+        createdByActorId: toNullableTrimmedString(session.createdByActorId),
+        updatedByActorId: toNullableTrimmedString(session.updatedByActorId),
+        createdAt: String(session.createdAt || sourceWatermark || '').trim(),
+        updatedAt: String(session.updatedAt || sourceWatermark || session.createdAt || '').trim(),
+        deletedAt: toNullableTrimmedString(session.deletedAt),
+    };
+}
+export function normalizeDocumentReviewCommentSyncPayload(raw, options) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const comment = raw;
+    const id = String(comment.id || '').trim();
+    const sessionId = String(options?.sessionId || comment.sessionId || '').trim();
+    if (!id || !sessionId)
+        return null;
+    return {
+        id,
+        sessionId,
+        body: typeof comment.body === 'string' ? comment.body : '',
+        anchor: (comment.anchor ?? null),
+        order: toOptionalNonNegativeInteger(comment.order),
+        authorActorId: toNullableTrimmedString(comment.authorActorId),
+        createdAt: String(comment.createdAt || options?.sourceWatermark || '').trim(),
+        updatedAt: String(comment.updatedAt || options?.sourceWatermark || comment.createdAt || '').trim(),
+        deletedAt: toNullableTrimmedString(comment.deletedAt),
+    };
+}
+export function normalizeAnnotatedAttachmentSessionSyncPayload(raw, expectedWorkspaceId, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const session = raw;
+    const id = String(session.id || '').trim();
+    const workspaceId = String(session.workspaceId || expectedWorkspaceId || '').trim();
+    const baseImageAssetId = String(session.baseImageAssetId || '').trim();
+    if (!id || !workspaceId || !baseImageAssetId)
+        return null;
+    if (expectedWorkspaceId && workspaceId !== expectedWorkspaceId)
+        return null;
+    return {
+        id,
+        workspaceId,
+        taskId: String(session.taskId || '').trim(),
+        baseImageAssetId,
+        title: toNullableTrimmedString(session.title),
+        globalInstruction: toNullableTrimmedString(session.globalInstruction),
+        annotations: Array.isArray(session.annotations) ? session.annotations : [],
+        createdByActorId: toNullableTrimmedString(session.createdByActorId),
+        updatedByActorId: toNullableTrimmedString(session.updatedByActorId),
+        createdAt: String(session.createdAt || sourceWatermark || '').trim(),
+        updatedAt: String(session.updatedAt || sourceWatermark || session.createdAt || '').trim(),
+        deletedAt: toNullableTrimmedString(session.deletedAt),
+    };
+}
+export function normalizeDeleteSyncPayload(raw, idKey) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const id = String(source[idKey] || source.id || '').trim();
+    if (!id)
+        return null;
+    return {
+        id,
+        deletedAt: String(source.deletedAt || source.watermark || new Date().toISOString()).trim(),
+    };
+}

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

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

package/dist/sync/collaborationSyncPayload.test.js

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeAiProfileSyncPayload, normalizeAnnotatedAttachmentSessionSyncPayload, normalizeDeleteSyncPayload, normalizeDocumentReviewCommentSyncPayload, normalizeDocumentReviewSessionSyncPayload, } from './collaborationSyncPayload';
+describe('collaborationSyncPayload', () => {
+    const normalizeSurfaceType = (value) => {
+        if (value === undefined || value === null || value === '')
+            return null;
+        return String(value).trim();
+    };
+    it('normalizes ai profile sync payloads with workspace and surface type', () => {
+        const profile = normalizeAiProfileSyncPayload({
+            id: 'profile-1',
+            workspaceId: 'workspace-a',
+            profileToken: ' token-1 ',
+            name: ' Agent ',
+            username: ' agent ',
+            icon: ' Bot ',
+            color: ' #111111 ',
+            surfaceType: 'agent',
+            providerMetadata: { foo: 'bar' },
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+            lastActiveAt: '2026-04-10T12:00:00.000Z',
+        }, 'workspace-a', normalizeSurfaceType, 'test.ai');
+        expect(profile).toEqual({
+            id: 'profile-1',
+            workspaceId: 'workspace-a',
+            profileToken: 'token-1',
+            name: 'Agent',
+            username: 'agent',
+            icon: 'Bot',
+            color: '#111111',
+            surfaceType: 'agent',
+            providerMetadata: { foo: 'bar' },
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+            lastActiveAt: '2026-04-10T12:00:00.000Z',
+        });
+    });
+    it('normalizes document review session and comment payloads', () => {
+        const session = normalizeDocumentReviewSessionSyncPayload({
+            id: 'session-1',
+            assetId: 'asset-1',
+            documentId: ' doc-1 ',
+            documentVersion: '2',
+            title: ' Review ',
+            status: 'resolved',
+            comments: [],
+            createdByActorId: ' ai-1 ',
+            updatedByActorId: ' ai-2 ',
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+        });
+        expect(session).toEqual(expect.objectContaining({
+            id: 'session-1',
+            assetId: 'asset-1',
+            documentId: 'doc-1',
+            documentVersion: 2,
+            title: 'Review',
+            status: 'resolved',
+            createdByActorId: 'ai-1',
+            updatedByActorId: 'ai-2',
+        }));
+        const comment = normalizeDocumentReviewCommentSyncPayload({
+            id: 'comment-1',
+            body: 'Looks good',
+            order: '3',
+            authorActorId: ' ai-3 ',
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+        }, { sessionId: 'session-1' });
+        expect(comment).toEqual(expect.objectContaining({
+            id: 'comment-1',
+            sessionId: 'session-1',
+            body: 'Looks good',
+            order: 3,
+            authorActorId: 'ai-3',
+        }));
+    });
+    it('normalizes annotated attachment sessions and delete payloads', () => {
+        const session = normalizeAnnotatedAttachmentSessionSyncPayload({
+            id: 'annotated-1',
+            workspaceId: 'workspace-a',
+            taskId: 'task-1',
+            baseImageAssetId: 'asset-img-1',
+            title: ' Notes ',
+            globalInstruction: ' Review this ',
+            annotations: [{ id: 'a1' }],
+            createdAt: '2026-04-10T10:00:00.000Z',
+            updatedAt: '2026-04-10T11:00:00.000Z',
+        }, 'workspace-a');
+        expect(session).toEqual(expect.objectContaining({
+            id: 'annotated-1',
+            workspaceId: 'workspace-a',
+            taskId: 'task-1',
+            baseImageAssetId: 'asset-img-1',
+            title: 'Notes',
+            globalInstruction: 'Review this',
+        }));
+        expect(normalizeDeleteSyncPayload({ sessionId: 'annotated-1', deletedAt: '2026-04-10T12:00:00.000Z' }, 'sessionId')).toEqual({
+            id: 'annotated-1',
+            deletedAt: '2026-04-10T12:00:00.000Z',
+        });
+    });
+});

package/dist/sync/collaborationSyncState.d.ts

@@ -0,0 +1,15 @@
+import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
+import type { WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot } from './workspaceSyncModel.js';
+type SyncCore = TaskforceCore & TaskforceSyncCapable;
+interface CollaborationSyncStateDeps {
+    core: SyncCore;
+}
+export declare function listWorkspaceSyncDocumentReviewSessionsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncDocumentReviewSessionSnapshot[];
+export declare function listWorkspaceSyncDocumentReviewCommentsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncDocumentReviewCommentSnapshot[];
+export declare function listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
+export declare function createCollaborationSyncState(deps: CollaborationSyncStateDeps): {
+    listWorkspaceSyncDocumentReviewSessionsSnapshot: (workspaceId?: string) => WorkspaceSyncDocumentReviewSessionSnapshot[];
+    listWorkspaceSyncDocumentReviewCommentsSnapshot: (workspaceId?: string) => WorkspaceSyncDocumentReviewCommentSnapshot[];
+    listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: (workspaceId?: string) => WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
+};
+export {};

package/dist/sync/collaborationSyncState.js

@@ -0,0 +1,60 @@
+export function listWorkspaceSyncDocumentReviewSessionsSnapshot(deps, workspaceId = 'default') {
+    return deps.core.listDocumentReviewSessionsForSync({ workspaceId, includeDeleted: true })
+        .map((session) => ({
+        id: session.id,
+        assetId: session.assetId,
+        documentId: session.documentId,
+        documentVersion: session.documentVersion,
+        title: session.title,
+        status: session.status,
+        comments: session.comments,
+        createdByActorId: session.createdByActorId,
+        updatedByActorId: session.updatedByActorId,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        deletedAt: session.deletedAt,
+    }))
+        .filter((session) => session.id.length > 0 && session.assetId.length > 0);
+}
+export function listWorkspaceSyncDocumentReviewCommentsSnapshot(deps, workspaceId = 'default') {
+    return deps.core.listDocumentReviewCommentsForSync({ workspaceId, includeDeleted: true })
+        .map((comment) => ({
+        id: comment.id,
+        sessionId: comment.sessionId,
+        body: comment.body,
+        anchor: comment.anchor,
+        order: comment.order,
+        authorActorId: comment.authorActorId,
+        createdAt: comment.createdAt,
+        updatedAt: comment.updatedAt,
+        deletedAt: comment.deletedAt,
+    }))
+        .filter((comment) => comment.id.length > 0 && comment.sessionId.length > 0);
+}
+export function listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps, workspaceId = 'default') {
+    return deps.core.listAnnotatedAttachmentSessionsForSync({ workspaceId, includeDeleted: true })
+        .map((session) => ({
+        id: session.id,
+        workspaceId: session.workspaceId,
+        taskId: session.taskId,
+        baseImageAssetId: session.baseImageAssetId,
+        title: session.title,
+        globalInstruction: session.globalInstruction,
+        annotations: session.annotations,
+        createdByActorId: session.createdByActorId,
+        updatedByActorId: session.updatedByActorId,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        deletedAt: session.deletedAt,
+    }))
+        .filter((session) => (session.id.length > 0
+        && session.workspaceId.length > 0
+        && session.baseImageAssetId.length > 0));
+}
+export function createCollaborationSyncState(deps) {
+    return {
+        listWorkspaceSyncDocumentReviewSessionsSnapshot: (workspaceId = 'default') => listWorkspaceSyncDocumentReviewSessionsSnapshot(deps, workspaceId),
+        listWorkspaceSyncDocumentReviewCommentsSnapshot: (workspaceId = 'default') => listWorkspaceSyncDocumentReviewCommentsSnapshot(deps, workspaceId),
+        listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: (workspaceId = 'default') => listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps, workspaceId),
+    };
+}

package/dist/sync/contentSyncPayload.d.ts

@@ -0,0 +1,45 @@
+import type { WorkspaceAssetLinkRole } from '../storage/workspaceAssetStore.js';
+export interface DocumentSyncPayload {
+    path: string;
+    updatedAt: string;
+    content: string;
+    assetId?: string;
+    documentId?: string | null;
+    referenceNumber?: number | null;
+    version?: number | null;
+    taskId?: string | null;
+    logicalName?: string | null;
+    caption?: string | null;
+    originalFilename?: string | null;
+    linkRole?: WorkspaceAssetLinkRole;
+}
+export interface DocumentDeleteSyncPayload {
+    path: string;
+    deletedAt: string;
+    assetId?: string;
+}
+export interface BinaryAssetSyncPayload {
+    path: string;
+    updatedAt: string;
+    contentBase64: string;
+    assetId?: string;
+    kind: 'image' | 'file';
+    mimeType: string;
+    referenceNumber?: number | null;
+    taskId?: string | null;
+    logicalName?: string | null;
+    caption?: string | null;
+    originalFilename?: string | null;
+    linkRole?: WorkspaceAssetLinkRole;
+}
+export interface BinaryAssetDeleteSyncPayload {
+    path: string;
+    deletedAt: string;
+    assetId?: string;
+}
+export declare function normalizeDocumentSyncPayload(raw: unknown, normalizePath: (rawPath: unknown) => string | null): DocumentSyncPayload | null;
+export declare function normalizeDocumentDeleteSyncPayload(raw: unknown, normalizePath: (rawPath: unknown) => string | null, defaultDeletedAt?: string): DocumentDeleteSyncPayload | null;
+export declare function normalizeBinaryAssetSyncPayload(raw: unknown, normalizePath: (rawPath: unknown) => string | null): BinaryAssetSyncPayload | null;
+export declare function normalizeBinaryAssetDeleteSyncPayload(raw: unknown, normalizePath: (rawPath: unknown) => string | null, defaultDeletedAt?: string): BinaryAssetDeleteSyncPayload | null;
+export declare function serializeDocumentSyncPayload(raw: unknown): DocumentSyncPayload | null;
+export declare function serializeBinaryAssetSyncPayload(raw: unknown): BinaryAssetSyncPayload | null;

package/dist/sync/contentSyncPayload.js

@@ -0,0 +1,104 @@
+function toOptionalTrimmedString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+function toNullableTrimmedString(value) {
+    const normalized = toOptionalTrimmedString(value);
+    return normalized ?? null;
+}
+function toOptionalPositiveInteger(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const normalized = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(normalized))
+        return null;
+    return Math.max(1, Math.floor(normalized));
+}
+export function normalizeDocumentSyncPayload(raw, normalizePath) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const path = normalizePath(source.path);
+    if (!path)
+        return null;
+    return {
+        path,
+        updatedAt: String(source.updatedAt || source.watermark || '').trim(),
+        content: typeof source.content === 'string' ? source.content : '',
+        assetId: toOptionalTrimmedString(source.assetId),
+        documentId: toNullableTrimmedString(source.documentId),
+        referenceNumber: toOptionalPositiveInteger(source.referenceNumber),
+        version: toOptionalPositiveInteger(source.version),
+        taskId: toNullableTrimmedString(source.taskId),
+        logicalName: toNullableTrimmedString(source.logicalName),
+        caption: toNullableTrimmedString(source.caption),
+        originalFilename: toNullableTrimmedString(source.originalFilename),
+        linkRole: source.linkRole === 'reference' ? 'reference' : 'attachment',
+    };
+}
+export function normalizeDocumentDeleteSyncPayload(raw, normalizePath, defaultDeletedAt) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const path = normalizePath(source.path);
+    if (!path)
+        return null;
+    return {
+        path,
+        deletedAt: String(source.deletedAt || source.watermark || defaultDeletedAt || new Date().toISOString()).trim(),
+        assetId: toOptionalTrimmedString(source.assetId),
+    };
+}
+export function normalizeBinaryAssetSyncPayload(raw, normalizePath) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const path = normalizePath(source.path);
+    if (!path)
+        return null;
+    return {
+        path,
+        updatedAt: String(source.updatedAt || source.watermark || '').trim(),
+        contentBase64: typeof source.contentBase64 === 'string' ? source.contentBase64 : '',
+        assetId: toOptionalTrimmedString(source.assetId),
+        kind: source.kind === 'image' ? 'image' : 'file',
+        mimeType: toOptionalTrimmedString(source.mimeType) || 'application/octet-stream',
+        referenceNumber: toOptionalPositiveInteger(source.referenceNumber),
+        taskId: toNullableTrimmedString(source.taskId),
+        logicalName: toNullableTrimmedString(source.logicalName),
+        caption: toNullableTrimmedString(source.caption),
+        originalFilename: toNullableTrimmedString(source.originalFilename),
+        linkRole: source.linkRole === 'reference'
+            ? 'reference'
+            : source.kind === 'image'
+                ? 'image'
+                : 'attachment',
+    };
+}
+export function normalizeBinaryAssetDeleteSyncPayload(raw, normalizePath, defaultDeletedAt) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const source = raw;
+    const path = normalizePath(source.path);
+    if (!path)
+        return null;
+    return {
+        path,
+        deletedAt: String(source.deletedAt || source.watermark || defaultDeletedAt || new Date().toISOString()).trim(),
+        assetId: toOptionalTrimmedString(source.assetId),
+    };
+}
+export function serializeDocumentSyncPayload(raw) {
+    return normalizeDocumentSyncPayload(raw, (value) => {
+        const normalized = typeof value === 'string' ? value.trim() : '';
+        return normalized.length > 0 ? normalized : null;
+    });
+}
+export function serializeBinaryAssetSyncPayload(raw) {
+    return normalizeBinaryAssetSyncPayload(raw, (value) => {
+        const normalized = typeof value === 'string' ? value.trim() : '';
+        return normalized.length > 0 ? normalized : null;
+    });
+}

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

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

package/dist/sync/contentSyncPayload.test.js

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeBinaryAssetDeleteSyncPayload, normalizeBinaryAssetSyncPayload, normalizeDocumentDeleteSyncPayload, normalizeDocumentSyncPayload, serializeBinaryAssetSyncPayload, serializeDocumentSyncPayload, } from './contentSyncPayload';
+describe('contentSyncPayload', () => {
+    const normalizeDocumentPath = (rawPath) => {
+        const value = typeof rawPath === 'string' ? rawPath.trim() : '';
+        return value.startsWith('docs/') ? value : null;
+    };
+    const normalizeAssetPath = (rawPath) => {
+        const value = typeof rawPath === 'string' ? rawPath.trim() : '';
+        return value.startsWith('workspaces/') ? value : null;
+    };
+    it('normalizes document sync payloads and trims metadata', () => {
+        const payload = normalizeDocumentSyncPayload({
+            path: 'docs/spec.md',
+            updatedAt: '2026-04-10T17:00:00.000Z',
+            content: '# Spec',
+            documentId: ' doc-1 ',
+            referenceNumber: '7',
+            version: '2',
+            taskId: ' task-1 ',
+            logicalName: ' Spec ',
+            caption: ' Draft ',
+            originalFilename: ' spec.md ',
+            linkRole: 'reference',
+        }, normalizeDocumentPath);
+        expect(payload).toEqual({
+            path: 'docs/spec.md',
+            updatedAt: '2026-04-10T17:00:00.000Z',
+            content: '# Spec',
+            assetId: undefined,
+            documentId: 'doc-1',
+            referenceNumber: 7,
+            version: 2,
+            taskId: 'task-1',
+            logicalName: 'Spec',
+            caption: 'Draft',
+            originalFilename: 'spec.md',
+            linkRole: 'reference',
+        });
+    });
+    it('normalizes binary asset sync payloads and delete payloads', () => {
+        const payload = normalizeBinaryAssetSyncPayload({
+            path: 'workspaces/a/assets/images/test.png',
+            updatedAt: '2026-04-10T17:00:00.000Z',
+            contentBase64: 'YWJj',
+            kind: 'image',
+            mimeType: ' image/png ',
+            referenceNumber: '3',
+            taskId: ' task-2 ',
+            logicalName: ' Hero ',
+            caption: ' Screenshot ',
+            originalFilename: ' hero.png ',
+            linkRole: 'image',
+        }, normalizeAssetPath);
+        expect(payload).toEqual({
+            path: 'workspaces/a/assets/images/test.png',
+            updatedAt: '2026-04-10T17:00:00.000Z',
+            contentBase64: 'YWJj',
+            assetId: undefined,
+            kind: 'image',
+            mimeType: 'image/png',
+            referenceNumber: 3,
+            taskId: 'task-2',
+            logicalName: 'Hero',
+            caption: 'Screenshot',
+            originalFilename: 'hero.png',
+            linkRole: 'image',
+        });
+        expect(normalizeBinaryAssetDeleteSyncPayload({ path: 'workspaces/a/assets/images/test.png', deletedAt: '2026-04-10T18:00:00.000Z' }, normalizeAssetPath)).toEqual({
+            path: 'workspaces/a/assets/images/test.png',
+            deletedAt: '2026-04-10T18:00:00.000Z',
+            assetId: undefined,
+        });
+    });
+    it('serializes push-side document and asset payloads without route-local parsing', () => {
+        expect(serializeDocumentSyncPayload({
+            path: 'docs/plan.md',
+            updatedAt: '2026-04-10T17:00:00.000Z',
+            content: 'hello',
+            referenceNumber: '9',
+            linkRole: 'reference',
+        })).toEqual(expect.objectContaining({
+            path: 'docs/plan.md',
+            referenceNumber: 9,
+            linkRole: 'reference',
+        }));
+        expect(serializeBinaryAssetSyncPayload({
+            path: 'workspaces/a/assets/files/file.bin',
+            updatedAt: '2026-04-10T17:00:00.000Z',
+            contentBase64: 'YWJj',
+            kind: 'file',
+            mimeType: 'application/octet-stream',
+        })).toEqual(expect.objectContaining({
+            path: 'workspaces/a/assets/files/file.bin',
+            kind: 'file',
+            contentBase64: 'YWJj',
+        }));
+        expect(normalizeDocumentDeleteSyncPayload({ path: 'docs/plan.md', deletedAt: '2026-04-10T19:00:00.000Z' }, normalizeDocumentPath)).toEqual({
+            path: 'docs/plan.md',
+            deletedAt: '2026-04-10T19:00:00.000Z',
+            assetId: undefined,
+        });
+    });
+});