@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/engine/workspaceSyncImmutableContentStager.js

@@ -0,0 +1,202 @@
+import { randomUUID } from 'crypto';
+import { buildWorkspaceSyncContentIdentity } from './workspaceSyncContentVersionStore.js';
+const PREPARATION_LEASE_MS = 5 * 60_000;
+const GC_LEASE_MS = 5 * 60_000;
+const DEFAULT_PROVIDER_OPERATION_TIMEOUT_MS = 4 * 60_000;
+export class WorkspaceSyncImmutableContentOperationTimeoutError extends Error {
+    operation;
+    timeoutMs;
+    code = 'SYNC_CONTENT_OPERATION_TIMEOUT';
+    constructor(operation, timeoutMs) {
+        super(`Immutable content provider ${operation} timed out after ${timeoutMs}ms.`);
+        this.operation = operation;
+        this.timeoutMs = timeoutMs;
+        this.name = 'WorkspaceSyncImmutableContentOperationTimeoutError';
+    }
+}
+export class WorkspaceSyncImmutableContentStager {
+    store;
+    providers;
+    now;
+    operationTails = new Map();
+    providerOperationTimeoutMs;
+    constructor(store, providers, now, options = {}) {
+        this.store = store;
+        this.providers = providers;
+        this.now = now;
+        const providerOperationTimeoutMs = options.providerOperationTimeoutMs
+            ?? DEFAULT_PROVIDER_OPERATION_TIMEOUT_MS;
+        if (!Number.isSafeInteger(providerOperationTimeoutMs)
+            || providerOperationTimeoutMs <= 0
+            || providerOperationTimeoutMs >= Math.min(PREPARATION_LEASE_MS, GC_LEASE_MS)) {
+            throw new TypeError('providerOperationTimeoutMs must be a positive integer shorter than the durable content-operation lease.');
+        }
+        this.providerOperationTimeoutMs = providerOperationTimeoutMs;
+    }
+    async prepare(input) {
+        const identity = buildWorkspaceSyncContentIdentity(input);
+        return this.runExclusive(identity.versionId, async () => {
+            const provider = this.providers[input.storageProvider];
+            if (!provider) {
+                throw new TypeError(`No immutable content provider is configured for ${input.storageProvider}.`);
+            }
+            const version = this.store.createOrValidatePreparing({
+                ...input,
+                createdAt: this.now(),
+            });
+            const claimedAt = this.now();
+            const preparationToken = randomUUID();
+            const claim = this.store.claimPreparation({
+                tenantId: version.tenantId,
+                workspaceId: version.workspaceId,
+                versionId: version.versionId,
+                preparationToken,
+                claimedAt,
+                leaseUntil: new Date(Date.parse(claimedAt) + PREPARATION_LEASE_MS).toISOString(),
+            });
+            if (!claim.requiresProviderPreparation) {
+                return claim.version;
+            }
+            if (!claim.attemptPhysicalKey) {
+                throw new Error('Immutable content preparation claim did not register an attempt key.');
+            }
+            try {
+                const prepared = await this.runProviderOperation('prepare', (signal) => provider.prepare({
+                    physicalKey: claim.attemptPhysicalKey,
+                    body: input.body,
+                    mimeType: claim.version.mimeType,
+                    expectedSha256: claim.version.contentSha256,
+                    expectedSizeBytes: claim.version.sizeBytes,
+                }, { signal }));
+                if (prepared.physicalKey !== claim.attemptPhysicalKey) {
+                    throw new Error('Immutable content provider returned a different physical key.');
+                }
+                return this.store.markReady({
+                    tenantId: claim.version.tenantId,
+                    workspaceId: claim.version.workspaceId,
+                    versionId: claim.version.versionId,
+                    readyAt: this.now(),
+                    preparationToken,
+                    preparedPhysicalKey: claim.attemptPhysicalKey,
+                });
+            }
+            catch (error) {
+                this.store.releasePreparation({
+                    tenantId: claim.version.tenantId,
+                    workspaceId: claim.version.workspaceId,
+                    versionId: claim.version.versionId,
+                    preparationToken,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+        });
+    }
+    async collect(input) {
+        return this.runExclusive(input.versionId, async () => {
+            const claimedAt = this.now();
+            const gcClaimToken = randomUUID();
+            const version = this.store.claimGcCandidate({
+                ...input,
+                gcClaimToken,
+                claimedAt,
+                leaseUntil: new Date(Date.parse(claimedAt) + GC_LEASE_MS).toISOString(),
+            });
+            try {
+                const provider = this.providers[version.storageProvider];
+                if (!provider) {
+                    throw new TypeError(`No immutable content provider is configured for ${version.storageProvider}.`);
+                }
+                await this.runProviderOperation('delete', (signal) => provider.delete(version.physicalKey, { signal }));
+            }
+            catch (error) {
+                this.store.recordGcFailure({
+                    ...input,
+                    gcClaimToken,
+                    failedAt: this.now(),
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+            return this.store.markDeleted({
+                ...input,
+                gcClaimToken,
+                deletedAt: this.now(),
+            });
+        });
+    }
+    async collectPreparationAttempt(input) {
+        return this.runExclusive(`${input.versionId}:${input.preparationToken}`, async () => {
+            const claimedAt = this.now();
+            const gcClaimToken = randomUUID();
+            let attempt;
+            attempt = this.store.claimPreparationAttemptGc({
+                ...input,
+                gcClaimToken,
+                claimedAt,
+                leaseUntil: new Date(Date.parse(claimedAt) + GC_LEASE_MS).toISOString(),
+            });
+            try {
+                const provider = this.providers[attempt.storageProvider];
+                if (!provider) {
+                    throw new TypeError(`No immutable content provider is configured for ${attempt.storageProvider}.`);
+                }
+                await this.runProviderOperation('delete', (signal) => provider.delete(attempt.physicalKey, { signal }));
+            }
+            catch (error) {
+                this.store.recordPreparationAttemptGcFailure({
+                    ...input,
+                    gcClaimToken,
+                    failedAt: this.now(),
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+            this.store.completePreparationAttemptGc({
+                ...input,
+                gcClaimToken,
+                deletedAt: this.now(),
+            });
+        });
+    }
+    async runExclusive(versionId, operation) {
+        const previous = this.operationTails.get(versionId) ?? Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        const tail = previous.catch(() => undefined).then(() => current);
+        this.operationTails.set(versionId, tail);
+        await previous.catch(() => undefined);
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+            if (this.operationTails.get(versionId) === tail) {
+                this.operationTails.delete(versionId);
+            }
+        }
+    }
+    runProviderOperation(operationName, operation) {
+        const controller = new AbortController();
+        const timeoutError = new WorkspaceSyncImmutableContentOperationTimeoutError(operationName, this.providerOperationTimeoutMs);
+        const timeout = setTimeout(() => controller.abort(timeoutError), this.providerOperationTimeoutMs);
+        timeout.unref?.();
+        return Promise.resolve()
+            .then(() => operation(controller.signal))
+            .then((value) => {
+            if (controller.signal.aborted && controller.signal.reason === timeoutError) {
+                throw timeoutError;
+            }
+            return value;
+        })
+            .catch((error) => {
+            if (controller.signal.aborted && controller.signal.reason === timeoutError) {
+                throw timeoutError;
+            }
+            throw error;
+        })
+            .finally(() => clearTimeout(timeout));
+    }
+}

package/dist/sync/engine/workspaceSyncPublishedContentResolver.d.ts

@@ -0,0 +1,43 @@
+import { type WorkspaceSyncContentKind, type WorkspaceSyncContentStorageProvider, type WorkspaceSyncContentVersionStore } from './workspaceSyncContentVersionStore.js';
+export type WorkspaceSyncPublishedContentResolveInput = {
+    tenantId: string;
+    workspaceId: string;
+    kind: WorkspaceSyncContentKind;
+    logicalPath: string;
+    legacyProvider: WorkspaceSyncContentStorageProvider;
+};
+type WorkspaceSyncPublishedContentIdentity = Pick<WorkspaceSyncPublishedContentResolveInput, 'kind' | 'logicalPath'>;
+export type WorkspaceSyncPublishedLegacyContent = WorkspaceSyncPublishedContentIdentity & {
+    source: 'legacy';
+    physicalKey: string;
+    storageProvider: WorkspaceSyncContentStorageProvider;
+};
+export type WorkspaceSyncPublishedDeletedContent = WorkspaceSyncPublishedContentIdentity & {
+    source: 'deleted';
+    deletedAt: string;
+};
+export type WorkspaceSyncPublishedVersionedContent = WorkspaceSyncPublishedContentIdentity & {
+    source: 'versioned';
+    versionId: string;
+    physicalKey: string;
+    storageProvider: WorkspaceSyncContentStorageProvider;
+    contentSha256: string;
+    sizeBytes: number;
+    mimeType: string;
+};
+export type WorkspaceSyncPublishedContent = WorkspaceSyncPublishedLegacyContent | WorkspaceSyncPublishedDeletedContent | WorkspaceSyncPublishedVersionedContent;
+export declare class WorkspaceSyncPublishedContentResolutionError extends Error {
+    readonly code = "WORKSPACE_SYNC_PUBLISHED_CONTENT_INVALID";
+    constructor(message: string);
+}
+export declare function verifyWorkspaceSyncPublishedContentBody(body: Buffer, content: Pick<WorkspaceSyncPublishedVersionedContent, 'contentSha256' | 'sizeBytes'>, label: string): Buffer;
+type ContentVersionReader = Pick<WorkspaceSyncContentVersionStore, 'getHead' | 'getVersion'>;
+export declare class WorkspaceSyncPublishedContentResolver {
+    private readonly store;
+    constructor(store: ContentVersionReader);
+    resolve(rawInput: WorkspaceSyncPublishedContentResolveInput): WorkspaceSyncPublishedContent;
+    private validateHeadScope;
+    private validatePublishedVersion;
+    private fail;
+}
+export {};

package/dist/sync/engine/workspaceSyncPublishedContentResolver.js

@@ -0,0 +1,142 @@
+import { createHash } from 'crypto';
+import { buildWorkspaceSyncContentIdentity, matchesWorkspaceSyncContentPhysicalKey, } from './workspaceSyncContentVersionStore.js';
+export class WorkspaceSyncPublishedContentResolutionError extends Error {
+    code = 'WORKSPACE_SYNC_PUBLISHED_CONTENT_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'WorkspaceSyncPublishedContentResolutionError';
+    }
+}
+export function verifyWorkspaceSyncPublishedContentBody(body, content, label) {
+    const actualSha256 = createHash('sha256').update(body).digest('hex');
+    if (body.byteLength !== content.sizeBytes || actualSha256 !== content.contentSha256) {
+        throw new WorkspaceSyncPublishedContentResolutionError(`${label} failed immutable content integrity verification.`);
+    }
+    return body;
+}
+function requireUnchangedIdentity(value, field) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new TypeError(`${field} is required.`);
+    }
+    return value;
+}
+function validateInput(input) {
+    if (input.kind !== 'document' && input.kind !== 'asset') {
+        throw new TypeError('kind must be document or asset.');
+    }
+    if (input.legacyProvider !== 'local' && input.legacyProvider !== 'r2') {
+        throw new TypeError('legacyProvider must be local or r2.');
+    }
+    return {
+        tenantId: requireUnchangedIdentity(input.tenantId, 'tenantId'),
+        workspaceId: requireUnchangedIdentity(input.workspaceId, 'workspaceId'),
+        kind: input.kind,
+        logicalPath: requireUnchangedIdentity(input.logicalPath, 'logicalPath'),
+        legacyProvider: input.legacyProvider,
+    };
+}
+export class WorkspaceSyncPublishedContentResolver {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    resolve(rawInput) {
+        const input = validateInput(rawInput);
+        const head = this.store.getHead(input);
+        if (!head) {
+            return {
+                source: 'legacy',
+                kind: input.kind,
+                logicalPath: input.logicalPath,
+                physicalKey: input.logicalPath,
+                storageProvider: input.legacyProvider,
+            };
+        }
+        this.validateHeadScope(input, head);
+        if (head.deletedAt != null) {
+            if (!head.deletedAt.trim()
+                || head.versionId != null
+                || head.contentSha256 != null
+                || head.sizeBytes != null) {
+                this.fail(input, 'the tombstone metadata is invalid');
+            }
+            return {
+                source: 'deleted',
+                kind: input.kind,
+                logicalPath: input.logicalPath,
+                deletedAt: head.deletedAt,
+            };
+        }
+        const { versionId, contentSha256, sizeBytes, } = head;
+        if (versionId == null || contentSha256 == null || sizeBytes == null) {
+            this.fail(input, 'the live head has incomplete version metadata');
+        }
+        const version = this.store.getVersion({
+            tenantId: input.tenantId,
+            workspaceId: input.workspaceId,
+            versionId,
+        });
+        if (!version) {
+            this.fail(input, `the referenced version ${versionId} does not exist`);
+        }
+        this.validatePublishedVersion(input, {
+            ...head,
+            versionId,
+            contentSha256,
+            sizeBytes,
+        }, version);
+        return {
+            source: 'versioned',
+            kind: input.kind,
+            logicalPath: input.logicalPath,
+            versionId: version.versionId,
+            physicalKey: version.physicalKey,
+            storageProvider: version.storageProvider,
+            contentSha256: version.contentSha256,
+            sizeBytes: version.sizeBytes,
+            mimeType: version.mimeType,
+        };
+    }
+    validateHeadScope(input, head) {
+        if (head.tenantId !== input.tenantId
+            || head.workspaceId !== input.workspaceId
+            || head.kind !== input.kind
+            || head.logicalPath !== input.logicalPath) {
+            this.fail(input, 'the resolved head belongs to a different logical identity');
+        }
+    }
+    validatePublishedVersion(input, head, version) {
+        if (version.tenantId !== input.tenantId
+            || version.workspaceId !== input.workspaceId
+            || version.versionId !== head.versionId
+            || version.kind !== input.kind
+            || version.logicalPath !== input.logicalPath) {
+            this.fail(input, 'the referenced version belongs to a different logical identity');
+        }
+        if (version.state !== 'published' || version.deletedAt != null) {
+            this.fail(input, `the referenced version is not published (state ${version.state})`);
+        }
+        if (version.contentSha256 !== head.contentSha256
+            || version.sizeBytes !== head.sizeBytes) {
+            this.fail(input, 'the head fingerprint does not match the referenced version');
+        }
+        let deterministic;
+        try {
+            deterministic = buildWorkspaceSyncContentIdentity(version);
+        }
+        catch {
+            this.fail(input, 'the referenced version has invalid immutable metadata');
+        }
+        if (deterministic.versionId !== version.versionId
+            || !matchesWorkspaceSyncContentPhysicalKey({
+                basePhysicalKey: deterministic.physicalKey,
+                storageGeneration: version.storageGeneration,
+                physicalKey: version.physicalKey,
+            })) {
+            this.fail(input, 'the referenced version has a corrupt immutable identity');
+        }
+    }
+    fail(input, reason) {
+        throw new WorkspaceSyncPublishedContentResolutionError(`Cannot resolve published workspace content ${input.kind}:${input.logicalPath}: ${reason}.`);
+    }
+}

package/dist/sync/engine/workspaceSyncServerContentRuntime.d.ts

@@ -0,0 +1,26 @@
+import type { ObjectStorageClient } from '../../storage/objectStorageClient.js';
+import { WorkspaceSyncContentLifecycleAdapter } from './workspaceSyncContentLifecycleAdapter.js';
+import type { WorkspaceSyncContentVersionStore } from './workspaceSyncContentVersionStore.js';
+import { WorkspaceSyncImmutableContentStager } from './workspaceSyncImmutableContentStager.js';
+export interface WorkspaceSyncServerContentRuntimeOptions {
+    contentVersionStore: WorkspaceSyncContentVersionStore;
+    localBasePath: string;
+    getObjectStorageClient(): ObjectStorageClient | null;
+    now(): string;
+}
+export interface WorkspaceSyncServerContentRuntime {
+    immutableContentStager: WorkspaceSyncImmutableContentStager;
+    contentLifecycle: WorkspaceSyncContentLifecycleAdapter;
+}
+export declare class WorkspaceSyncServerContentProviderUnavailableError extends Error {
+    readonly code = "SYNC_CONTENT_PROVIDER_UNAVAILABLE";
+    constructor();
+}
+/**
+ * Process-owned immutable-content services for the server sync runner.
+ *
+ * The local provider is always available. R2 calls resolve the current object
+ * storage client at the provider boundary so credentials and configuration are
+ * neither copied nor retained by this long-lived runtime.
+ */
+export declare function createWorkspaceSyncServerContentRuntime(options: WorkspaceSyncServerContentRuntimeOptions): WorkspaceSyncServerContentRuntime;

package/dist/sync/engine/workspaceSyncServerContentRuntime.js

@@ -0,0 +1,41 @@
+import { WorkspaceSyncContentLifecycleAdapter } from './workspaceSyncContentLifecycleAdapter.js';
+import { WorkspaceSyncLocalImmutableContentProvider, WorkspaceSyncR2ImmutableContentProvider, } from './workspaceSyncImmutableContentProvider.js';
+import { WorkspaceSyncImmutableContentStager } from './workspaceSyncImmutableContentStager.js';
+export class WorkspaceSyncServerContentProviderUnavailableError extends Error {
+    code = 'SYNC_CONTENT_PROVIDER_UNAVAILABLE';
+    constructor() {
+        super('R2 immutable content was requested, but object storage is not currently configured.');
+        this.name = 'WorkspaceSyncServerContentProviderUnavailableError';
+    }
+}
+function createDynamicR2Client(getObjectStorageClient) {
+    const currentClient = () => {
+        const client = getObjectStorageClient();
+        if (!client) {
+            throw new WorkspaceSyncServerContentProviderUnavailableError();
+        }
+        return client;
+    };
+    return {
+        putObject: (physicalKey, body, mimeType, options) => currentClient().putObject(physicalKey, body, mimeType, options),
+        getObject: (physicalKey, options) => currentClient().getObject(physicalKey, options),
+        deleteObject: (physicalKey, options) => currentClient().deleteObject(physicalKey, options),
+    };
+}
+/**
+ * Process-owned immutable-content services for the server sync runner.
+ *
+ * The local provider is always available. R2 calls resolve the current object
+ * storage client at the provider boundary so credentials and configuration are
+ * neither copied nor retained by this long-lived runtime.
+ */
+export function createWorkspaceSyncServerContentRuntime(options) {
+    const immutableContentStager = new WorkspaceSyncImmutableContentStager(options.contentVersionStore, {
+        local: new WorkspaceSyncLocalImmutableContentProvider(options.localBasePath),
+        r2: new WorkspaceSyncR2ImmutableContentProvider(createDynamicR2Client(options.getObjectStorageClient)),
+    }, options.now);
+    return {
+        immutableContentStager,
+        contentLifecycle: new WorkspaceSyncContentLifecycleAdapter(options.contentVersionStore),
+    };
+}

package/dist/sync/engine/workspaceSyncServerDataServices.d.ts

@@ -0,0 +1,44 @@
+import type { TaskforceCore, TaskforceSyncCapable } from '../../core/Taskforce.js';
+import type { ResolvedObjectStorageConfig } from '../../storage/objectStorage.js';
+import { ObjectStorageClient } from '../../storage/objectStorageClient.js';
+import { WorkspaceAssetStore } from '../../storage/workspaceAssetStore.js';
+import { createCollaborationSyncState } from '../collaborationSyncState.js';
+import { createContentSyncState, type CachedWorkspaceSyncDocument } from '../contentSyncState.js';
+import { createWorkspaceSyncV2ChangeDispatcher, type WorkspaceSyncV2DiagnosticRecorder } from './workspaceSyncV2ChangeDispatcher.js';
+import { WorkspaceSyncContentVersionStore } from './workspaceSyncContentVersionStore.js';
+import { WorkspaceSyncPublishedContentResolver } from './workspaceSyncPublishedContentResolver.js';
+import type { WorkspaceSyncServerContentRuntime } from './workspaceSyncServerContentRuntime.js';
+import { type WorkspaceSyncV2PreparedContentPlan } from './workspaceSyncV2PreparedContent.js';
+import type { WorkspaceSyncChange } from '../workspaceSyncModel.js';
+type ServerSyncCore = TaskforceCore & TaskforceSyncCapable;
+export interface WorkspaceSyncServerDataServicesOptions {
+    core: ServerSyncCore;
+    resolveObjectStorageConfig(): ResolvedObjectStorageConfig;
+    now(): Date;
+}
+/**
+ * Shared process-owned data services used by the HTTP sync routes today and by
+ * the dark server runner during composition. Construct this value once so both
+ * callers observe the same content cache, readers, storage access, and
+ * diagnostics boundary.
+ */
+export interface WorkspaceSyncServerDataServices {
+    workspaceAssetStore: WorkspaceAssetStore | null;
+    contentVersionStore: WorkspaceSyncContentVersionStore | null;
+    publishedContentResolver: Pick<WorkspaceSyncPublishedContentResolver, 'resolve'>;
+    workspaceDocumentSnapshotCache: Map<string, Map<string, CachedWorkspaceSyncDocument>>;
+    contentSyncState: ReturnType<typeof createContentSyncState>;
+    collaborationSyncState: ReturnType<typeof createCollaborationSyncState>;
+    normalizeWorkspaceSyncDocumentPath(rawPath: unknown): string | null;
+    getObjectStorageClient(): ObjectStorageClient | null;
+    hasObjectStorageClient(): boolean;
+    recordSyncDiagnostic: WorkspaceSyncV2DiagnosticRecorder;
+    configureContentRuntime(contentRuntime: WorkspaceSyncServerContentRuntime): void;
+    prepareWorkspaceSyncV2Content(workspaceId: string, changes: readonly WorkspaceSyncChange[]): Promise<WorkspaceSyncV2PreparedContentPlan>;
+    dispatchWorkspaceSyncChanges: ReturnType<typeof createWorkspaceSyncV2ChangeDispatcher>['dispatch'];
+    dispatchWorkspaceSyncMetadataAtomically: ReturnType<typeof createWorkspaceSyncV2ChangeDispatcher>['dispatchMetadataAtomically'];
+    dispatchWorkspaceSyncPreparedContentAtomically: ReturnType<typeof createWorkspaceSyncV2ChangeDispatcher>['dispatchPreparedContentAtomically'];
+}
+export declare function normalizeWorkspaceSyncDocumentPath(rawPath: unknown): string | null;
+export declare function createWorkspaceSyncServerDataServices(options: WorkspaceSyncServerDataServicesOptions): WorkspaceSyncServerDataServices;
+export {};

package/dist/sync/engine/workspaceSyncServerDataServices.js

@@ -0,0 +1,143 @@
+import * as path from 'path';
+import { normalizeTaskDataRelativePath, ObjectStorageClient, } from '../../storage/objectStorageClient.js';
+import { WorkspaceAssetStore } from '../../storage/workspaceAssetStore.js';
+import { createCollaborationSyncState, } from '../collaborationSyncState.js';
+import { createContentSyncState, } from '../contentSyncState.js';
+import { createWorkspaceSyncV2ChangeDispatcher, } from './workspaceSyncV2ChangeDispatcher.js';
+import { WorkspaceSyncContentVersionStore } from './workspaceSyncContentVersionStore.js';
+import { WorkspaceSyncPublishedContentResolver } from './workspaceSyncPublishedContentResolver.js';
+import { prepareWorkspaceSyncV2Content, } from './workspaceSyncV2PreparedContent.js';
+export function normalizeWorkspaceSyncDocumentPath(rawPath) {
+    const value = String(rawPath || '').trim().replace(/\\/g, '/');
+    if (!value || value.includes('\0') || value.startsWith('/'))
+        return null;
+    const normalized = path.posix.normalize(value);
+    if (!normalized
+        || normalized.startsWith('../')
+        || normalized.includes('/../')
+        || normalized === '..') {
+        return null;
+    }
+    const lower = normalized.toLowerCase();
+    if (!lower.endsWith('.md') && !lower.endsWith('.markdown'))
+        return null;
+    if (/^workspaces\/[^/]+\/assets\/documents\//.test(normalized))
+        return normalized;
+    if (normalized.startsWith('docs/'))
+        return normalized;
+    return null;
+}
+export function createWorkspaceSyncServerDataServices(options) {
+    const { core } = options;
+    const workspaceAssetStore = typeof core.getDatabaseAdapter === 'function'
+        && typeof core.getTenantId === 'function'
+        ? new WorkspaceAssetStore(core.getDatabaseAdapter(), core.getTenantId())
+        : null;
+    const contentVersionStore = workspaceAssetStore
+        ? new WorkspaceSyncContentVersionStore(core.getDatabaseAdapter())
+        : null;
+    const publishedContentResolver = contentVersionStore
+        ? new WorkspaceSyncPublishedContentResolver(contentVersionStore)
+        : {
+            resolve: (input) => ({
+                source: 'legacy',
+                kind: input.kind,
+                logicalPath: input.logicalPath,
+                physicalKey: input.logicalPath,
+                storageProvider: input.legacyProvider,
+            }),
+        };
+    const getObjectStorageClient = () => {
+        const resolved = options.resolveObjectStorageConfig();
+        return resolved.provider === 'r2' ? new ObjectStorageClient(resolved) : null;
+    };
+    const recordSyncDiagnostic = (workspaceId, eventType, errorMessage, details) => {
+        try {
+            core.recordSyncEvent(workspaceId, {
+                eventType,
+                status: 'error',
+                errorMessage,
+                requestMs: 0,
+                details,
+            });
+        }
+        catch {
+            // Diagnostics must never interrupt synchronization.
+        }
+        if (details && Object.keys(details).length > 0) {
+            // eslint-disable-next-line no-console
+            console.warn('[Taskforce Sync Diagnostic]', {
+                workspaceId,
+                eventType,
+                errorMessage,
+                ...details,
+            });
+        }
+    };
+    const workspaceDocumentSnapshotCache = new Map();
+    const contentSyncState = createContentSyncState({
+        core,
+        workspaceAssetStore,
+        getObjectStorageClient,
+        normalizeWorkspaceSyncDocumentPath,
+        normalizeTaskDataRelativePath: (rawPath) => normalizeTaskDataRelativePath(String(rawPath || '').trim()),
+        recordSyncDiagnostic,
+        workspaceDocumentSnapshotCache,
+        publishedContentResolver,
+    });
+    const collaborationSyncState = createCollaborationSyncState({ core });
+    const dispatcherOptions = {
+        core,
+        contentSyncState,
+        workspaceAssetStore,
+        hasObjectStorageClient: () => Boolean(getObjectStorageClient()),
+        normalizeWorkspaceSyncDocumentPath,
+        recordSyncDiagnostic,
+        ...(contentVersionStore ? { contentVersionStore } : {}),
+        now: options.now,
+    };
+    const workspaceSyncV2ChangeDispatcher = createWorkspaceSyncV2ChangeDispatcher(dispatcherOptions);
+    let immutableContentStager = null;
+    const configureContentRuntime = (contentRuntime) => {
+        immutableContentStager = contentRuntime.immutableContentStager;
+        dispatcherOptions.contentLifecycle = contentRuntime.contentLifecycle;
+    };
+    const prepareV2Content = async (workspaceId, changes) => {
+        if (!immutableContentStager) {
+            const error = new Error('Atomic browser V2 content apply requires the local immutable-content runtime.');
+            error.code = 'SYNC_V2_CONTENT_RUNTIME_REQUIRED';
+            error.statusCode = 409;
+            throw error;
+        }
+        return prepareWorkspaceSyncV2Content({
+            tenantId: core.getTenantId(),
+            workspaceId,
+            changes: [...changes],
+            storageProvider: getObjectStorageClient() ? 'r2' : 'local',
+            normalizeDocumentPath: normalizeWorkspaceSyncDocumentPath,
+            normalizeAssetPath: (value) => normalizeTaskDataRelativePath(String(value || '')),
+            stager: immutableContentStager,
+            now: () => options.now().toISOString(),
+        });
+    };
+    const dispatchWorkspaceSyncChanges = workspaceSyncV2ChangeDispatcher.dispatch;
+    const dispatchWorkspaceSyncMetadataAtomically = workspaceSyncV2ChangeDispatcher.dispatchMetadataAtomically;
+    const dispatchWorkspaceSyncPreparedContentAtomically = workspaceSyncV2ChangeDispatcher.dispatchPreparedContentAtomically;
+    return {
+        workspaceAssetStore,
+        contentVersionStore,
+        publishedContentResolver,
+        workspaceDocumentSnapshotCache,
+        contentSyncState,
+        collaborationSyncState,
+        normalizeWorkspaceSyncDocumentPath,
+        getObjectStorageClient,
+        hasObjectStorageClient: () => Boolean(getObjectStorageClient()),
+        recordSyncDiagnostic,
+        configureContentRuntime,
+        prepareWorkspaceSyncV2Content: prepareV2Content,
+        dispatchWorkspaceSyncChanges,
+        dispatchWorkspaceSyncMetadataAtomically,
+        dispatchWorkspaceSyncPreparedContentAtomically,
+    };
+}