@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/server/routes/syncAuxRoutes.d.ts

@@ -0,0 +1,15 @@
+import type { IncomingMessage } from 'http';
+import type { WorkspaceAssetStore } from '../../storage/workspaceAssetStore.js';
+import type { SyncAddRoute, SyncResolveRequestAccess, SyncRouteAuthConfig, SyncRouteCore } from './syncRouteTypes.js';
+interface RegisterWorkspaceSyncAuxRoutesArgs {
+    addRoute: SyncAddRoute;
+    core: SyncRouteCore;
+    context: {
+        authConfig?: SyncRouteAuthConfig | null;
+    };
+    resolveRequestAccess: SyncResolveRequestAccess;
+    requestWorkspaceId: (req: IncomingMessage) => string | null | undefined;
+    workspaceAssetStore: WorkspaceAssetStore | null;
+}
+export declare function registerWorkspaceSyncAuxRoutes({ addRoute, core, context, resolveRequestAccess, requestWorkspaceId, workspaceAssetStore }: RegisterWorkspaceSyncAuxRoutesArgs): void;
+export {};

package/dist/server/routes/syncAuxRoutes.js

@@ -0,0 +1,91 @@
+import { applyWorkspaceRepair } from '../../sync/workspaceRepair.js';
+import { normalizeSyncEventDetails } from '../../utils/syncEventDetails.js';
+import { parseJsonBody } from './primitives.js';
+import { requireAuthenticatedSyncRequest } from './syncRouteGuards.js';
+export function registerWorkspaceSyncAuxRoutes({ addRoute, core, context, resolveRequestAccess, requestWorkspaceId, workspaceAssetStore }) {
+    // GET /api/taskforce/sync/events - Query recent sync events (local runtime only)
+    addRoute('GET', '/api/taskforce/sync/events', async (req, res) => {
+        const authConfig = context.authConfig;
+        const access = authConfig?.enabled ? resolveRequestAccess(req, authConfig) : null;
+        if (access && (!access.authenticated || !access.userId || access.userId === 'anonymous')) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Authentication required.' }));
+            return;
+        }
+        const url = new URL(req.url || '/', 'http://localhost');
+        const workspaceId = String(url.searchParams.get('workspace_id') || access?.workspaceId || '').trim() || 'default';
+        const limit = Math.min(500, Math.max(1, Number(url.searchParams.get('limit') || '100')));
+        const events = core.listSyncEvents(workspaceId, limit);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, events }));
+    });
+    // POST /api/taskforce/sync/events - Record a client-side sync event (pull results, handshake outcomes)
+    addRoute('POST', '/api/taskforce/sync/events', async (req, res) => {
+        const authConfig = context.authConfig;
+        const access = authConfig?.enabled ? resolveRequestAccess(req, authConfig) : null;
+        if (access && (!access.authenticated || !access.userId || access.userId === 'anonymous')) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Authentication required.' }));
+            return;
+        }
+        const body = await parseJsonBody(req);
+        const allowedEventTypes = ['pull', 'handshake', 'bootstrap', 'apply', 'push'];
+        const eventType = String(body?.eventType || '').trim().toLowerCase();
+        if (!allowedEventTypes.includes(eventType)) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Invalid eventType.' }));
+            return;
+        }
+        const workspaceId = String(body?.workspaceId || access?.workspaceId || '').trim() || 'default';
+        core.recordSyncEvent(workspaceId, {
+            eventType: eventType,
+            status: String(body?.status || '') === 'error' ? 'error' : 'success',
+            statusCode: typeof body?.statusCode === 'number' ? body.statusCode : undefined,
+            errorMessage: typeof body?.errorMessage === 'string' ? body.errorMessage.slice(0, 500) : undefined,
+            changeCount: typeof body?.changeCount === 'number' ? body.changeCount : undefined,
+            requestMs: typeof body?.requestMs === 'number' ? body.requestMs : undefined,
+            details: normalizeSyncEventDetails(body?.details)
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true }));
+    });
+    // POST /api/taskforce/sync/workspace/repair-startup - Auto-repair missing asset/document
+    // metadata on workspace open. Only safe fixups: re-registers DB records for files that
+    // exist on disk but have no (or a stale deleted) metadata entry. Never deletes files.
+    // Called once by the sync orchestrator when the workspace becomes active.
+    addRoute('POST', '/api/taskforce/sync/workspace/repair-startup', async (req, res) => {
+        const authConfig = context.authConfig;
+        if (authConfig?.enabled && !requireAuthenticatedSyncRequest({
+            req,
+            res,
+            authConfig,
+            resolveRequestAccess
+        })) {
+            return;
+        }
+        const body = await parseJsonBody(req);
+        const workspaceId = String(body?.workspaceId || requestWorkspaceId(req) || '').trim() || 'default';
+        if (!workspaceAssetStore) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, applied: 0, skipped: 0, failed: 0, detail: 'Asset store unavailable.' }));
+            return;
+        }
+        const { basePath } = core.getPaths();
+        const result = applyWorkspaceRepair({
+            workspaceId,
+            basePath,
+            tasks: core.listTasks(workspaceId)?.tasks || [],
+            archivedTasks: core.listArchive(workspaceId)?.archived || [],
+            deletedTasks: core.listWorkspaceSyncDeletes(workspaceId) || [],
+            workspaceAssetStore,
+            upsertDocumentWatermark: (targetWorkspaceId, docPath, contentHash, updatedAt) => {
+                core.upsertDocumentWatermark(targetWorkspaceId, docPath, contentHash, updatedAt);
+            }
+        });
+        const applied = result.actionsApplied.filter((a) => a.status === 'applied').length;
+        const failed = result.actionsApplied.filter((a) => a.status === 'failed').length;
+        const skipped = result.actionsApplied.filter((a) => a.status === 'skipped').length;
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true, applied, skipped, failed }));
+    });
+}

package/dist/server/routes/syncAuxRoutes.test.d.ts

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

package/dist/server/routes/syncAuxRoutes.test.js

@@ -0,0 +1,158 @@
+import { Readable } from 'stream';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { applyWorkspaceRepair } from '../../sync/workspaceRepair.js';
+import { registerWorkspaceSyncAuxRoutes } from './syncAuxRoutes';
+vi.mock('../../sync/workspaceRepair.js', () => ({
+    applyWorkspaceRepair: vi.fn()
+}));
+function createJsonRequest(method, url, body) {
+    const chunks = body === undefined ? [] : [JSON.stringify(body)];
+    const req = Readable.from(chunks);
+    req.method = method;
+    req.url = url;
+    req.headers = body === undefined
+        ? {}
+        : { 'content-type': 'application/json' };
+    return req;
+}
+function createResponse() {
+    return {
+        writeHead: vi.fn(),
+        end: vi.fn()
+    };
+}
+function registerAuxRoutes(overrides) {
+    const handlers = new Map();
+    const addRoute = (method, path, handler) => {
+        handlers.set(`${method} ${path}`, handler);
+    };
+    const core = {
+        listSyncEvents: vi.fn(() => []),
+        recordSyncEvent: vi.fn(),
+        getPaths: vi.fn(() => ({ basePath: '/tmp/taskforce-sync' })),
+        listTasks: vi.fn(() => ({ tasks: [] })),
+        listArchive: vi.fn(() => ({ archived: [] })),
+        listWorkspaceSyncDeletes: vi.fn(() => []),
+        upsertDocumentWatermark: vi.fn()
+    };
+    registerWorkspaceSyncAuxRoutes({
+        addRoute,
+        core,
+        context: { authConfig: (overrides?.authConfig ?? null) },
+        resolveRequestAccess: overrides?.resolveRequestAccess ?? (() => ({
+            authenticated: true,
+            userId: 'user-1',
+            workspaceId: 'workspace-local'
+        })),
+        requestWorkspaceId: () => null,
+        workspaceAssetStore: overrides?.workspaceAssetStore ?? null
+    });
+    return { handlers, core };
+}
+describe('syncAuxRoutes', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('returns zeroed startup repair results when the asset store is unavailable', async () => {
+        const { handlers } = registerAuxRoutes({
+            authConfig: { enabled: false, runtimeMode: 'local' },
+            workspaceAssetStore: null
+        });
+        const handler = handlers.get('POST /api/taskforce/sync/workspace/repair-startup');
+        const req = createJsonRequest('POST', '/api/taskforce/sync/workspace/repair-startup', {
+            workspaceId: 'workspace-local'
+        });
+        const res = createResponse();
+        await handler?.(req, res);
+        expect(res.writeHead).toHaveBeenCalledWith(200, { 'Content-Type': 'application/json' });
+        expect(res.end).toHaveBeenCalledWith(JSON.stringify({
+            success: true,
+            applied: 0,
+            skipped: 0,
+            failed: 0,
+            detail: 'Asset store unavailable.'
+        }));
+    });
+    it('requires authentication for startup repair when auth is enabled', async () => {
+        const { handlers } = registerAuxRoutes({
+            authConfig: { enabled: true, runtimeMode: 'local' },
+            resolveRequestAccess: () => ({
+                authenticated: false,
+                userId: null,
+                workspaceId: null
+            }),
+            workspaceAssetStore: {}
+        });
+        const handler = handlers.get('POST /api/taskforce/sync/workspace/repair-startup');
+        const req = createJsonRequest('POST', '/api/taskforce/sync/workspace/repair-startup', {
+            workspaceId: 'workspace-local'
+        });
+        const res = createResponse();
+        await handler?.(req, res);
+        expect(res.writeHead).toHaveBeenCalledWith(401, { 'Content-Type': 'application/json' });
+        expect(res.end).toHaveBeenCalledWith(JSON.stringify({
+            success: false,
+            error: 'Authentication required.'
+        }));
+    });
+    it('returns applied, skipped, and failed counts from startup repair actions', async () => {
+        vi.mocked(applyWorkspaceRepair).mockReturnValue({
+            actionsApplied: [
+                { status: 'applied' },
+                { status: 'applied' },
+                { status: 'skipped' },
+                { status: 'failed' }
+            ]
+        });
+        const { handlers, core } = registerAuxRoutes({
+            authConfig: { enabled: false, runtimeMode: 'local' },
+            workspaceAssetStore: {}
+        });
+        const handler = handlers.get('POST /api/taskforce/sync/workspace/repair-startup');
+        const req = createJsonRequest('POST', '/api/taskforce/sync/workspace/repair-startup', {
+            workspaceId: 'workspace-local'
+        });
+        const res = createResponse();
+        await handler?.(req, res);
+        expect(applyWorkspaceRepair).toHaveBeenCalledWith(expect.objectContaining({
+            workspaceId: 'workspace-local',
+            basePath: '/tmp/taskforce-sync',
+            tasks: [],
+            archivedTasks: [],
+            deletedTasks: []
+        }));
+        expect(core.getPaths).toHaveBeenCalled();
+        expect(res.end).toHaveBeenCalledWith(JSON.stringify({
+            success: true,
+            applied: 2,
+            skipped: 1,
+            failed: 1
+        }));
+    });
+    it('sanitizes sync event details before recording them', async () => {
+        const { handlers, core } = registerAuxRoutes({
+            authConfig: { enabled: false, runtimeMode: 'local' }
+        });
+        const handler = handlers.get('POST /api/taskforce/sync/events');
+        const req = createJsonRequest('POST', '/api/taskforce/sync/events', {
+            workspaceId: 'workspace-local',
+            eventType: 'apply',
+            status: 'error',
+            errorMessage: 'Reference drift detected.',
+            details: {
+                nested: {
+                    items: ['doc-1', 'doc-2']
+                }
+            }
+        });
+        const res = createResponse();
+        await handler?.(req, res);
+        expect(core.recordSyncEvent).toHaveBeenCalledWith('workspace-local', expect.objectContaining({
+            details: {
+                nested: {
+                    items: ['doc-1', 'doc-2']
+                }
+            }
+        }));
+    });
+});

package/dist/server/routes/syncPullApplyRoutes.d.ts

@@ -0,0 +1,36 @@
+import type { IncomingMessage } from 'http';
+import { buildWorkspacePullFeed } from '../../sync/workspacePullFeed.js';
+import type { WorkspaceSyncChange, WorkspaceSyncWorkspaceMemberSnapshot } from '../../sync/workspaceSyncModel.js';
+import type { SyncAddRoute, SyncResolveRequestAccess, SyncRouteAuthConfig, SyncRouteCore } from './syncRouteTypes.js';
+interface RegisterWorkspacePullApplySyncRoutesArgs {
+    addRoute: SyncAddRoute;
+    core: SyncRouteCore;
+    context: {
+        authConfig?: SyncRouteAuthConfig | null;
+    };
+    auditAuthAction: (req: IncomingMessage, action: string, details: Record<string, unknown>) => void;
+    resolveErrorStatusCode: (error: unknown, fallback?: number) => number;
+    requestWorkspaceId: (req: IncomingMessage) => string | null | undefined;
+    resolveRequestAccess: SyncResolveRequestAccess;
+    contentSyncState: Parameters<typeof buildWorkspacePullFeed>[0]['contentSyncState'];
+    collaborationSyncState: Parameters<typeof buildWorkspacePullFeed>[0]['collaborationSyncState'];
+    decodeWorkspaceSyncCursor: (raw: string | null | undefined) => {
+        u: string;
+        id: string;
+    } | null;
+    encodeWorkspaceSyncCursor: (cursor: {
+        u: string;
+        id: string;
+    } | null) => string | null;
+    normalizeWorkspaceMemberSyncSnapshot: (workspaceId: string, raw: Record<string, unknown> | null | undefined) => WorkspaceSyncWorkspaceMemberSnapshot | null;
+    dispatchWorkspaceSyncChanges: (workspaceId: string, incomingChanges: WorkspaceSyncChange[], options?: {
+        allowReferenceNumberReassignment?: boolean;
+        workspaceMembers?: WorkspaceSyncWorkspaceMemberSnapshot[];
+    }) => Promise<{
+        result: any;
+        deleteCount: number;
+        emittedEventIds: string[];
+    }>;
+}
+export declare function registerWorkspacePullApplySyncRoutes({ addRoute, core, context, auditAuthAction, resolveErrorStatusCode, requestWorkspaceId, resolveRequestAccess, contentSyncState, collaborationSyncState, decodeWorkspaceSyncCursor, encodeWorkspaceSyncCursor, normalizeWorkspaceMemberSyncSnapshot, dispatchWorkspaceSyncChanges }: RegisterWorkspacePullApplySyncRoutesArgs): void;
+export {};

package/dist/server/routes/syncPullApplyRoutes.js

@@ -0,0 +1,204 @@
+import { buildWorkspacePullFeed } from '../../sync/workspacePullFeed.js';
+import { parseJsonBody } from './primitives.js';
+import { requireAuthenticatedSyncRequest, requireEnabledSyncAuth, resolveAuthorizedSyncWorkspace, } from './syncRouteGuards.js';
+export function registerWorkspacePullApplySyncRoutes({ addRoute, core, context, auditAuthAction, resolveErrorStatusCode, requestWorkspaceId, resolveRequestAccess, contentSyncState, collaborationSyncState, decodeWorkspaceSyncCursor, encodeWorkspaceSyncCursor, normalizeWorkspaceMemberSyncSnapshot, dispatchWorkspaceSyncChanges }) {
+    // GET /api/taskforce/sync/workspace/pull - Incremental workspace task deltas with cursor paging
+    addRoute('GET', '/api/taskforce/sync/workspace/pull', async (req, res) => {
+        const authConfig = context.authConfig;
+        if (!requireEnabledSyncAuth(res, authConfig)) {
+            return;
+        }
+        const access = requireAuthenticatedSyncRequest({
+            req,
+            res,
+            authConfig,
+            resolveRequestAccess,
+            auditAuthAction,
+            unauthorizedAuditAction: 'sync-workspace-pull-unauthorized'
+        });
+        if (!access) {
+            return;
+        }
+        const url = new URL(req.url || '/api/taskforce/sync/workspace/pull', 'http://localhost');
+        const targetWorkspaceId = resolveAuthorizedSyncWorkspace({
+            req,
+            res,
+            core,
+            access,
+            requestedWorkspaceId: String(url.searchParams.get('workspaceId') || '').trim(),
+            auditAuthAction,
+            missingWorkspaceAuditAction: 'sync-workspace-pull-missing-workspace',
+            forbiddenWorkspaceAuditAction: 'sync-workspace-pull-forbidden'
+        });
+        if (!targetWorkspaceId) {
+            return;
+        }
+        const repairMode = url.searchParams.get('repair') === '1' || url.searchParams.get('repair') === 'true';
+        const rawCursor = repairMode ? '' : String(url.searchParams.get('cursor') || '').trim();
+        const cursor = decodeWorkspaceSyncCursor(rawCursor);
+        if (rawCursor && !cursor) {
+            auditAuthAction(req, 'sync-workspace-pull-invalid-cursor', {
+                workspaceId: targetWorkspaceId
+            });
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: 'Invalid sync cursor.',
+                code: 'INVALID_SYNC_CURSOR'
+            }));
+            return;
+        }
+        const requestedLimit = Number.parseInt(String(url.searchParams.get('limit') || ''), 10);
+        const pageSize = Number.isFinite(requestedLimit) && requestedLimit > 0
+            ? Math.max(1, Math.min(500, Math.floor(requestedLimit)))
+            : 200;
+        const { workspaceMembers, changes, nextCursor, hasMore, diagnostics } = await buildWorkspacePullFeed({
+            core,
+            workspaceId: targetWorkspaceId,
+            cursor,
+            pageSize,
+            encodeWorkspaceSyncCursor,
+            contentSyncState,
+            collaborationSyncState,
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            success: true,
+            workspaceId: targetWorkspaceId,
+            workspaceMembers,
+            changes,
+            nextCursor,
+            hasMore,
+            diagnostics
+        }));
+        try {
+            auditAuthAction(req, 'sync-workspace-pull-success', {
+                workspaceId: targetWorkspaceId,
+                returnedChanges: changes.length,
+                hasMore,
+                repairMode,
+                diagnostics
+            });
+        }
+        catch {
+            // post-response diagnostics must never cause an unhandled rejection
+        }
+    });
+    // POST /api/taskforce/sync/workspace/apply-local - Apply pulled cloud deltas into local workspace store
+    addRoute('POST', '/api/taskforce/sync/workspace/apply-local', async (req, res) => {
+        const startedAtMs = Date.now();
+        const authConfig = context.authConfig;
+        if (authConfig?.runtimeMode === 'cloud') {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: 'Local apply endpoint is only available in local runtime.' }));
+            return;
+        }
+        const body = await parseJsonBody(req, 50 * 1024 * 1024);
+        const bodyWorkspaceId = String(body?.workspaceId || '').trim();
+        const headerWorkspaceId = String(Array.isArray(req.headers['x-taskforce-workspace-id'])
+            ? req.headers['x-taskforce-workspace-id'][0]
+            : req.headers['x-taskforce-workspace-id'] || '').trim();
+        let workspaceId = bodyWorkspaceId || headerWorkspaceId || requestWorkspaceId(req);
+        if (authConfig?.enabled) {
+            const access = requireAuthenticatedSyncRequest({
+                req,
+                res,
+                authConfig,
+                resolveRequestAccess,
+                auditAuthAction,
+                unauthorizedAuditAction: 'sync-workspace-apply-unauthorized'
+            });
+            if (!access) {
+                return;
+            }
+            if (workspaceId && workspaceId !== 'default' && workspaceId !== 'null') {
+                const authorizedWorkspaceId = resolveAuthorizedSyncWorkspace({
+                    req,
+                    res,
+                    core,
+                    access,
+                    requestedWorkspaceId: workspaceId,
+                    auditAuthAction,
+                    forbiddenWorkspaceAuditAction: 'sync-workspace-apply-forbidden'
+                });
+                if (!authorizedWorkspaceId) {
+                    return;
+                }
+                workspaceId = authorizedWorkspaceId;
+            }
+            else {
+                const accessWorkspaceId = String(access.workspaceId || '').trim();
+                if (accessWorkspaceId && accessWorkspaceId !== 'default') {
+                    workspaceId = accessWorkspaceId;
+                }
+            }
+        }
+        if (!workspaceId || workspaceId === 'default' || workspaceId === 'null') {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: 'Workspace ID required.',
+                code: 'WORKSPACE_ID_REQUIRED'
+            }));
+            return;
+        }
+        const incomingChanges = Array.isArray(body?.changes) ? body.changes : [];
+        const workspaceMembers = Array.isArray(body?.workspaceMembers)
+            ? body.workspaceMembers
+                .map((entry) => normalizeWorkspaceMemberSyncSnapshot(workspaceId, entry && typeof entry === 'object' ? entry : null))
+                .filter((entry) => Boolean(entry))
+            : undefined;
+        const allowReferenceNumberReassignment = body?.repair === true;
+        try {
+            const { result, emittedEventIds } = await dispatchWorkspaceSyncChanges(workspaceId, incomingChanges, {
+                allowReferenceNumberReassignment,
+                ...(Array.isArray(workspaceMembers) ? { workspaceMembers } : {})
+            });
+            const durationMs = Date.now() - startedAtMs;
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: true,
+                workspaceId,
+                result,
+                emittedEventIds,
+                durationMs
+            }));
+            try {
+                core.recordSyncEvent(workspaceId, {
+                    eventType: 'apply',
+                    status: 'success',
+                    changeCount: incomingChanges.length,
+                    requestMs: durationMs
+                });
+            }
+            catch {
+                // success-path diagnostics must never flip a committed local apply into failure
+            }
+        }
+        catch (error) {
+            const statusCode = resolveErrorStatusCode(error, 400);
+            const durationMs = Date.now() - startedAtMs;
+            res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: false,
+                error: String(error?.message || 'Failed to apply local workspace deltas'),
+                code: error?.code,
+                details: error?.details || undefined,
+                durationMs
+            }));
+            try {
+                core.recordSyncEvent(workspaceId, {
+                    eventType: 'apply',
+                    status: 'error',
+                    statusCode,
+                    errorMessage: String(error?.message || 'Failed to apply local workspace deltas'),
+                    changeCount: incomingChanges.length,
+                    requestMs: durationMs
+                });
+            }
+            catch {
+                // error-path diagnostics must never suppress a committed error response
+            }
+        }
+    });
+}

package/dist/server/routes/syncPushRoutes.d.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage } from 'http';
+import type { WorkspaceSyncChange } from '../../sync/workspaceSyncModel.js';
+import type { SyncAddRoute, SyncResolveRequestAccess, SyncRouteAuthConfig, SyncRouteCore } from './syncRouteTypes.js';
+interface RegisterWorkspacePushSyncRoutesArgs {
+    addRoute: SyncAddRoute;
+    core: SyncRouteCore;
+    context: {
+        authConfig?: SyncRouteAuthConfig | null;
+    };
+    auditAuthAction: (req: IncomingMessage, action: string, details: Record<string, unknown>) => void;
+    resolveErrorStatusCode: (error: unknown, fallback?: number) => number;
+    resolveRequestAccess: SyncResolveRequestAccess;
+    readPushIdempotency: (workspaceId: string, key: string) => string | null;
+    writePushIdempotency: (workspaceId: string, key: string, payload: string) => void;
+    dispatchWorkspaceSyncChanges: (workspaceId: string, incomingChanges: WorkspaceSyncChange[], options?: {
+        allowReferenceNumberReassignment?: boolean;
+    }) => Promise<{
+        result: any;
+        deleteCount: number;
+        emittedEventIds: string[];
+    }>;
+}
+export declare function registerWorkspacePushSyncRoutes({ addRoute, core, context, auditAuthAction, resolveErrorStatusCode, resolveRequestAccess, readPushIdempotency, writePushIdempotency, dispatchWorkspaceSyncChanges }: RegisterWorkspacePushSyncRoutesArgs): void;
+export {};