@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/server/localWorkspaceSyncServerRuntime.js

@@ -0,0 +1,1163 @@
+import { LocalSyncCoordinatorHost } from '../sync/coordinator/localSyncCoordinatorHost.js';
+import { LocalSyncCoordinatorStore } from '../sync/coordinator/localSyncCoordinatorStore.js';
+import { LocalSyncDispatchTracker } from '../sync/coordinator/localSyncDispatchTracker.js';
+import { LocalSyncExecutionPermitStore } from '../sync/coordinator/localSyncExecutionPermitStore.js';
+import { LocalSyncOwnershipDrainBarrier } from '../sync/coordinator/localSyncOwnershipDrainBarrier.js';
+import { LocalWorkspaceSyncRunner, } from '../sync/coordinator/localWorkspaceSyncRunner.js';
+import { reconcileSettledV3DispatchRecoveryObligations, } from '../sync/coordinator/localSyncV3DispatchRecoveryReconciler.js';
+import { LocalWorkspaceSyncRunnerStateStore } from '../sync/coordinator/localWorkspaceSyncRunnerState.js';
+import { WorkspaceSyncCredentialBroker, } from '../sync/coordinator/workspaceSyncCredentialBroker.js';
+import { WorkspaceSyncTransportGateway } from '../sync/coordinator/workspaceSyncTransportGateway.js';
+import { createWorkspaceSyncEngineServerApplyBoundary } from '../sync/engine/workspaceSyncEngineServerApplyBoundary.js';
+import { createServerWorkspaceSyncEngineLocalServices } from '../sync/engine/workspaceSyncEngineServerLocalServices.js';
+import { createServerWorkspaceSyncEngineRemoteServices } from '../sync/engine/workspaceSyncEngineServerRemoteServices.js';
+import { createWorkspaceSyncEngineServerRunnerOperations } from '../sync/engine/workspaceSyncEngineServerRunnerOperations.js';
+import { workspaceSyncTransferEvidenceEvent } from '../sync/engine/workspaceSyncTransferEvidence.js';
+import { createWorkspaceSyncEngineServerPushCandidateProvider, createWorkspaceSyncEngineServerSnapshotReader, } from '../sync/engine/workspaceSyncEngineServerSnapshotReader.js';
+import { readWorkspaceSyncLocalOwnershipSnapshot } from '../sync/v3/workspaceSyncLocalOwnershipSnapshot.js';
+import { resolveWorkspaceSyncV3CombinedWireContract, } from '../sync/v3/workspaceSyncV3CombinedWireContract.js';
+import { LocalWorkspaceSyncServerOutboxDispatcher, } from '../sync/v3/localWorkspaceSyncServerOutboxDispatcher.js';
+import { readWorkspaceSyncV3LocalOutboxStatus, } from '../sync/v3/workspaceSyncV3LocalOutboxStatus.js';
+import { shouldAdvanceLocalDataVersion, } from '../sync/coordinator/localSyncCommittedApplyPolicy.js';
+import { createWorkspaceSyncV3OriginAssertion, isStrongWorkspaceSyncV3OriginAssertionProfileToken, workspaceSyncV3OriginAssertionBinding, } from '../sync/v3/workspaceSyncV3OriginAssertion.js';
+import { WorkspaceSyncDurabilityStore } from '../sync/v3/syncDurabilityStore.js';
+import { resolveWorkspaceSyncV3AttachmentApplyObligations, } from '../sync/v3/workspaceSyncV3NestedTaskApply.js';
+import { normalizeTaskDataRelativePath } from '../storage/taskDataPath.js';
+const DEFAULT_SHUTDOWN_GRACE_MS = 15_000;
+const DEFAULT_PERIODIC_WAKE_MS = 30_000;
+const RUNNER_INITIALIZATION_ABORTED_BY_SHUTDOWN = 'SYNC_RUNNER_INITIALIZATION_ABORTED_BY_SHUTDOWN';
+const DEFAULT_OUTBOX_DRAIN_BUDGET_MS = 5_000;
+const DEFAULT_MIGRATION_OUTBOX_DRAIN_BUDGET_MS = 60_000;
+const REMOTE_PULL_WAKE_SOURCES = new Set([
+    'realtime',
+    'connectivity',
+    'credential',
+    'activation',
+    'periodic',
+]);
+export function isLocalSyncServerOwnershipTransferEnabled(env = process.env) {
+    return /^(1|true|on|yes)$/i.test(String(env.TASKFORCE_LOCAL_SYNC_SERVER_OWNERSHIP_TRANSFER_ENABLED || '').trim());
+}
+/**
+ * Dark composition capsule for server-owned local workspace synchronization.
+ *
+ * Construction and start retain browser-gateway ownership. Only the existing
+ * generation-fenced ownership lifecycle can prepare and synchronously activate
+ * a server runner. Production startup constructs this runtime only in the
+ * process holding the local sync lock; server ownership remains fenced until
+ * the activation phase explicitly enables ownership transfer.
+ */
+export class LocalWorkspaceSyncServerRuntime {
+    options;
+    coordinatorStore;
+    permitStore;
+    credentialBroker;
+    transportGateway;
+    dispatchTracker;
+    runnerStateStore;
+    host;
+    routeServices;
+    now;
+    setTimer;
+    clearTimer;
+    ownershipDrain;
+    runnerBundle = null;
+    runnerInitializationPromise = null;
+    periodicWakeTimer = null;
+    wakePromise = null;
+    pendingWakeSources = new Set();
+    suppressedRealtimeEventIds = new Set();
+    suppressedRealtimeEventIdQueue = [];
+    localRealtimeEventHighWatermarks = new Map();
+    pendingRemoteHintObservedAt = null;
+    pendingCommand = null;
+    offMutationWake = null;
+    offRealtimeWakeSuppression = null;
+    ordinaryWakeEpoch = 0;
+    shuttingDown = false;
+    shutdownPromise = null;
+    constructor(options) {
+        this.options = options;
+        this.assertCompositionInputs();
+        this.now = options.now || (() => new Date());
+        this.setTimer = options.setTimer || setTimeout;
+        this.clearTimer = options.clearTimer || clearTimeout;
+        const db = options.core.getDatabaseAdapter();
+        const nowIso = () => this.now().toISOString();
+        this.coordinatorStore = new LocalSyncCoordinatorStore(db, nowIso);
+        this.permitStore = new LocalSyncExecutionPermitStore(db, nowIso);
+        this.dispatchTracker = new LocalSyncDispatchTracker();
+        this.runnerStateStore = new LocalWorkspaceSyncRunnerStateStore(db, nowIso);
+        this.credentialBroker = new WorkspaceSyncCredentialBroker({
+            sessionCookieName: options.sessionCookieName,
+            validate: options.validateCredential,
+            now: this.now,
+        });
+        this.transportGateway = new WorkspaceSyncTransportGateway({
+            cloudBaseUrl: options.cloudBaseUrl,
+            credentialBroker: this.credentialBroker,
+            permitStore: this.permitStore,
+            fetchImpl: options.fetchImpl,
+            cloudflareAccess: options.cloudflareAccess,
+            now: this.now,
+            createV3OriginAssertion: (envelope, issuedAt) => {
+                const binding = workspaceSyncV3OriginAssertionBinding({
+                    tenantId: options.core.getTenantId(),
+                    envelope,
+                });
+                if (!binding)
+                    return null;
+                const profile = options.core.listAiProfiles(envelope.workspaceId)
+                    .find((candidate) => candidate.id === binding.profileId);
+                if (!profile
+                    || profile.seatScope !== 'local_unmetered'
+                    || !isStrongWorkspaceSyncV3OriginAssertionProfileToken(profile.profileToken)) {
+                    return null;
+                }
+                return createWorkspaceSyncV3OriginAssertion({
+                    binding,
+                    profileToken: profile.profileToken,
+                    issuedAt,
+                });
+            },
+        });
+        const lifecycle = this.createOwnershipLifecycle();
+        this.host = new LocalSyncCoordinatorHost({
+            store: this.coordinatorStore,
+            processLock: options.processLock,
+            validateWorkspaceAccess: options.validateWorkspaceAccess,
+            shutdownGraceMs: options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS,
+            ownershipRunnerLifecycle: lifecycle,
+            now: nowIso,
+        });
+        // The drain barrier must carry the exact coordinator host instance ID.
+        this.ownershipDrain = new LocalSyncOwnershipDrainBarrier({
+            permitStore: this.permitStore,
+            transportGateway: this.transportGateway,
+            dispatchTracker: this.dispatchTracker,
+            serverInstanceId: this.host.serverInstanceId,
+        });
+        this.routeServices = {
+            host: this.host,
+            permitStore: this.permitStore,
+            credentialBroker: this.credentialBroker,
+            transportGateway: this.transportGateway,
+            serverOwnershipTransferEnabled: isLocalSyncServerOwnershipTransferEnabled(options.env),
+            localDispatchTracker: this.dispatchTracker,
+            onCommandAccepted: (command) => this.onCommandAccepted(command),
+            requestWakeHint: (hint) => this.requestWake(hint.source, {
+                workspaceId: hint.workspaceId,
+                coordinatorGeneration: hint.coordinatorGeneration,
+            }, hint.eventIds),
+            onCredentialBound: (credential) => this.onCredentialBound(credential),
+            recordCommittedLocalApply: (workspaceId, coordinatorGeneration, applyResult) => {
+                if (!shouldAdvanceLocalDataVersion(applyResult))
+                    return;
+                this.coordinatorStore.advanceLocalDataVersion({
+                    workspaceId,
+                    expectedCoordinatorGeneration: coordinatorGeneration,
+                });
+            },
+            readWorkspaceStatus: (workspaceId, coordinatorGeneration) => {
+                const bundle = this.runnerBundle;
+                const runner = bundle
+                    && bundle.context.workspaceId === workspaceId
+                    && bundle.context.coordinatorGeneration === coordinatorGeneration
+                    ? bundle.runner.readStatus()
+                    : null;
+                return {
+                    runner,
+                    outbox: readWorkspaceSyncV3LocalOutboxStatus({
+                        db: options.core.getDatabaseAdapter(),
+                        tenantId: options.core.getTenantId(),
+                        workspaceId,
+                        now: this.now().toISOString(),
+                    }),
+                };
+            },
+        };
+    }
+    start() {
+        this.shuttingDown = false;
+        this.shutdownPromise = null;
+        if (!this.offRealtimeWakeSuppression) {
+            this.offRealtimeWakeSuppression = this.options.core.onRealtimeMutation((event) => {
+                const serverEpoch = String(event.serverEpoch || '').trim();
+                const seq = Number(event.seq);
+                if (!serverEpoch || !Number.isSafeInteger(seq) || seq < 1)
+                    return;
+                const previous = this.localRealtimeEventHighWatermarks.get(serverEpoch) || 0;
+                if (seq > previous) {
+                    this.localRealtimeEventHighWatermarks.set(serverEpoch, seq);
+                }
+            });
+        }
+        if (!this.offMutationWake) {
+            this.offMutationWake = this.options.core.onWorkspaceMutationCommitted((event) => {
+                const bundle = this.runnerBundle;
+                if (!bundle
+                    || event.workspaceId !== bundle.context.workspaceId
+                    || event.origin === 'workspace-sync-apply')
+                    return;
+                this.requestWake('mutation', {
+                    workspaceId: bundle.context.workspaceId,
+                    coordinatorGeneration: bundle.context.coordinatorGeneration,
+                });
+            });
+        }
+        // Host recovery performs no cloud I/O and does not recreate a server
+        // runner until a matching in-memory credential is attached.
+        const state = this.host.start();
+        if (state.activeWorkspaceId) {
+            this.permitStore.recoverPriorServerPermits({
+                currentServerInstanceId: this.host.serverInstanceId,
+                workspaceId: state.activeWorkspaceId,
+            });
+        }
+        this.reconcileSettledDispatchRecovery(state);
+        return state;
+    }
+    async bindCredential(input) {
+        const snapshot = await this.credentialBroker.bindFromCookieHeader(input);
+        await this.onCredentialBound(snapshot);
+        return snapshot;
+    }
+    async onCredentialBound(snapshot) {
+        if (this.shuttingDown) {
+            throw new Error('The server sync runtime is shutting down.');
+        }
+        if (snapshot.status !== 'ready'
+            || !snapshot.workspaceId
+            || snapshot.coordinatorGeneration === null) {
+            return this.host.readState();
+        }
+        let state = this.host.readState();
+        if (state.ownershipMode === 'stopped'
+            && state.transitionState === 'idle'
+            && state.activeWorkspaceId === snapshot.workspaceId
+            && state.coordinatorGeneration === snapshot.coordinatorGeneration) {
+            if (state.desiredOwnershipMode === 'server') {
+                state = await this.resumeServerAfterAuthenticatedRestart(state, snapshot);
+            }
+            else {
+                state = this.host.resumeBrowserGatewayAfterAuthenticatedRestart({
+                    workspaceId: snapshot.workspaceId,
+                    expectedCoordinatorGeneration: snapshot.coordinatorGeneration,
+                });
+            }
+        }
+        if (state.ownershipMode === 'server'
+            && state.transitionState === 'idle'
+            && state.activeWorkspaceId === snapshot.workspaceId
+            && state.coordinatorGeneration === snapshot.coordinatorGeneration) {
+            if (!this.runnerBundle) {
+                await this.ensureActiveRunnerBundle(state, snapshot);
+            }
+            this.requestWake('credential');
+        }
+        this.reconcileSettledDispatchRecovery(state);
+        return state;
+    }
+    async resumeServerAfterAuthenticatedRestart(state, credential) {
+        const bundle = await this.ensurePreparedRunnerBundle(state, credential);
+        try {
+            const resumed = this.host.resumeServerAfterAuthenticatedRestart({
+                workspaceId: state.activeWorkspaceId,
+                expectedCoordinatorGeneration: state.coordinatorGeneration,
+            }, () => {
+                bundle.runner.activate();
+                this.startPeriodicWake();
+            });
+            this.requestWake('credential');
+            return resumed;
+        }
+        catch (error) {
+            const current = this.host.readState();
+            if (current.ownershipMode === 'stopped'
+                && this.runnerBundle === bundle) {
+                this.stopPeriodicWake();
+                bundle.outbox.closeIntake();
+                await bundle.runner.stop();
+                this.runnerBundle = null;
+            }
+            throw error;
+        }
+    }
+    reconcileSettledDispatchRecovery(state) {
+        if (!state.activeWorkspaceId
+            || state.transitionState !== 'idle'
+            || (state.ownershipMode !== 'browser-gateway'
+                && state.ownershipMode !== 'server')) {
+            return;
+        }
+        try {
+            reconcileSettledV3DispatchRecoveryObligations({
+                permitStore: this.permitStore,
+                durabilityStore: new WorkspaceSyncDurabilityStore(this.options.core.getDatabaseAdapter()),
+                workspaceId: state.activeWorkspaceId,
+                coordinatorGeneration: state.coordinatorGeneration,
+                ownerMode: state.ownershipMode,
+            });
+        }
+        catch (error) {
+            this.options.reportInternalError?.(error, 'coordinator-v3-dispatch-recovery-reconcile');
+        }
+    }
+    async ensureActiveRunnerBundle(state, credential) {
+        return this.ensureRunnerBundle(state, credential, true);
+    }
+    async ensurePreparedRunnerBundle(state, credential) {
+        return this.ensureRunnerBundle(state, credential, false);
+    }
+    async ensureRunnerBundle(state, credential, activateAfterPrepare) {
+        if (this.runnerBundle)
+            return this.runnerBundle;
+        if (this.runnerInitializationPromise)
+            return this.runnerInitializationPromise;
+        const context = this.contextFor(state, credential);
+        const initialization = (async () => {
+            const bundle = this.createRunnerBundle(context);
+            try {
+                await bundle.runner.prepare(context);
+                if (this.shuttingDown) {
+                    throw Object.assign(new Error('The server sync runtime is shutting down.'), { code: RUNNER_INITIALIZATION_ABORTED_BY_SHUTDOWN });
+                }
+                if (this.runnerBundle) {
+                    bundle.outbox.closeIntake();
+                    await bundle.runner.stop();
+                    return this.runnerBundle;
+                }
+                this.runnerBundle = bundle;
+                if (activateAfterPrepare) {
+                    bundle.runner.activate();
+                    this.startPeriodicWake();
+                }
+                return bundle;
+            }
+            catch (error) {
+                if (this.runnerBundle === bundle)
+                    this.runnerBundle = null;
+                bundle.outbox.closeIntake();
+                try {
+                    await bundle.runner.stop();
+                }
+                catch {
+                    // Preserve the preparation failure that kept ownership stopped.
+                }
+                throw error;
+            }
+        })();
+        this.runnerInitializationPromise = initialization;
+        try {
+            return await initialization;
+        }
+        finally {
+            if (this.runnerInitializationPromise === initialization) {
+                this.runnerInitializationPromise = null;
+            }
+        }
+    }
+    requestWake(source, expectedScope, realtimeEventIds = []) {
+        if (this.shuttingDown || !this.runnerBundle)
+            return false;
+        const bundle = this.runnerBundle;
+        if (expectedScope
+            && (bundle.context.workspaceId !== expectedScope.workspaceId
+                || bundle.context.coordinatorGeneration !== expectedScope.coordinatorGeneration)) {
+            return false;
+        }
+        const state = this.host.readState();
+        if (state.ownershipMode !== 'server'
+            || state.transitionState !== 'idle'
+            || state.activeWorkspaceId !== bundle.context.workspaceId
+            || state.coordinatorGeneration !== bundle.context.coordinatorGeneration) {
+            return false;
+        }
+        if (source === 'realtime' && realtimeEventIds.length > 0) {
+            let hasUnsuppressedEvent = false;
+            for (const eventId of realtimeEventIds) {
+                const normalizedEventId = String(eventId || '').trim();
+                if (!normalizedEventId)
+                    continue;
+                if (!this.consumeSuppressedRealtimeEventId(normalizedEventId)) {
+                    hasUnsuppressedEvent = true;
+                }
+            }
+            if (!hasUnsuppressedEvent)
+                return true;
+        }
+        this.pendingWakeSources.add(source);
+        if (REMOTE_PULL_WAKE_SOURCES.has(source)) {
+            const observedAt = this.now().toISOString();
+            if (!this.pendingRemoteHintObservedAt
+                || Date.parse(observedAt) < Date.parse(this.pendingRemoteHintObservedAt)) {
+                this.pendingRemoteHintObservedAt = observedAt;
+            }
+        }
+        if (this.wakePromise)
+            return true;
+        this.beginWakeLoop(bundle, source);
+        return true;
+    }
+    consumeSuppressedRealtimeEventId(eventId) {
+        if (this.suppressedRealtimeEventIds.delete(eventId))
+            return true;
+        const separator = eventId.lastIndexOf(':');
+        if (separator <= 0 || separator >= eventId.length - 1)
+            return false;
+        const serverEpoch = eventId.slice(0, separator);
+        const seq = Number(eventId.slice(separator + 1));
+        if (!Number.isSafeInteger(seq) || seq < 1)
+            return false;
+        return seq <= (this.localRealtimeEventHighWatermarks.get(serverEpoch) || 0);
+    }
+    beginWakeLoop(bundle, source) {
+        // Defer the tracked wake so synchronous ownership activation can return
+        // and its surrounding database transaction can commit first.
+        this.wakePromise = Promise.resolve().then(async () => {
+            let cycles = 0;
+            while (cycles < 2
+                && this.pendingWakeSources.size > 0
+                && !this.shuttingDown
+                && this.runnerBundle === bundle) {
+                const wakeSources = new Set(this.pendingWakeSources);
+                const remoteHintObservedAt = [...wakeSources]
+                    .some((wakeSource) => REMOTE_PULL_WAKE_SOURCES.has(wakeSource))
+                    ? this.pendingRemoteHintObservedAt
+                    : null;
+                this.pendingWakeSources.clear();
+                if (remoteHintObservedAt) {
+                    this.pendingRemoteHintObservedAt = null;
+                }
+                cycles += 1;
+                await this.dispatchTracker.track(() => this.runWakeCycle(bundle, wakeSources, remoteHintObservedAt));
+            }
+        }).catch((error) => {
+            this.options.reportInternalError?.(error, `${source}-wake`);
+        }).finally(() => {
+            this.wakePromise = null;
+            if (this.pendingWakeSources.size > 0
+                && !this.shuttingDown
+                && this.runnerBundle === bundle) {
+                this.beginWakeLoop(bundle, source);
+            }
+        });
+    }
+    async runWakeCycle(bundle, wakeSources, remoteHintObservedAt) {
+        if (this.shuttingDown || this.runnerBundle !== bundle)
+            return;
+        bundle.runner.notifyCredentialAvailable();
+        if ([...wakeSources].some((source) => REMOTE_PULL_WAKE_SOURCES.has(source))) {
+            await bundle.runner.observeRemoteHint(remoteHintObservedAt ?? this.now().toISOString());
+        }
+        const command = this.pendingCommand
+            || this.coordinatorStore.listAcceptedRunnerCommands({
+                workspaceId: bundle.context.workspaceId,
+                coordinatorGeneration: bundle.context.coordinatorGeneration,
+            })[0]
+            || null;
+        this.pendingCommand = null;
+        if (command) {
+            if (bundle.runner.readStatus().checkpoint?.checkpoint.syncEnabled
+                && (command.type === 'Sync'
+                    || command.type === 'Retry'
+                    || command.type === 'Repair')) {
+                const migrationDrain = await this.drainMigrationOutbox(bundle.outbox, bundle.runner, command.commandId);
+                if (migrationDrain === 'v2-content-push-required') {
+                    this.pendingCommand = command;
+                    this.pendingWakeSources.add('outbox');
+                    await bundle.runner.pushContentPrerequisiteDue();
+                    return;
+                }
+                if (migrationDrain === 'budget-exhausted') {
+                    this.pendingCommand = command;
+                    this.pendingWakeSources.add('outbox');
+                    return;
+                }
+                if (migrationDrain === 'command-pending'
+                    || migrationDrain === 'disabled') {
+                    this.pendingCommand = command;
+                    this.pendingWakeSources.add('command');
+                    return;
+                }
+                const preDrain = await this.drainOutbox(bundle.outbox, bundle.runner, undefined, command.commandId);
+                if (preDrain === 'v2-content-push-required') {
+                    this.pendingCommand = command;
+                    this.pendingWakeSources.add('outbox');
+                    await bundle.runner.pushContentPrerequisiteDue();
+                    return;
+                }
+                if (preDrain === 'pull-required') {
+                    this.pendingCommand = command;
+                    this.pendingWakeSources.add('outbox');
+                    await bundle.runner.pullDue();
+                    return;
+                }
+                if (preDrain === 'budget-exhausted') {
+                    this.pendingCommand = command;
+                    this.pendingWakeSources.add('outbox');
+                    return;
+                }
+                if (preDrain === 'command-pending' || preDrain === 'disabled') {
+                    this.pendingCommand = command;
+                    this.pendingWakeSources.add('command');
+                    return;
+                }
+            }
+            await bundle.runner.executeCommand(command.commandId);
+            if (bundle.runner.readStatus().checkpoint?.checkpoint.syncEnabled) {
+                const drainResult = await this.drainOutbox(bundle.outbox, bundle.runner);
+                if (drainResult === 'pull-required') {
+                    await this.runFairnessPull(bundle);
+                }
+            }
+            return;
+        }
+        const status = bundle.runner.readStatus();
+        if (!status.checkpoint?.checkpoint.syncEnabled)
+            return;
+        const retry = status.checkpoint.checkpoint.retry;
+        if (retry && Date.parse(retry.retryAt) > this.now().getTime()) {
+            // Authoritative repair cannot proceed while covered local
+            // operations remain active. Keep settling those operations during
+            // the repair backoff window so a dependency that becomes due
+            // between repair attempts cannot starve both queues indefinitely.
+            if (retry.kind !== 'repair')
+                return;
+            const waitingDrain = await this.drainOutbox(bundle.outbox);
+            if (waitingDrain === 'v2-content-push-required') {
+                await bundle.runner.pushContentPrerequisiteDue();
+            }
+            else if (waitingDrain === 'budget-exhausted') {
+                this.pendingWakeSources.add('outbox');
+            }
+            return;
+        }
+        const retryDue = Boolean(retry);
+        const wakeEpoch = this.ordinaryWakeEpoch;
+        const coordinatorRecoveryPlan = this.permitStore.inspectAuthoritativeRepairRecoveryObligations(bundle.context.workspaceId);
+        if (retry?.kind === 'v2-content-push') {
+            // This retry exists specifically to publish content required by a
+            // blocked durable operation. Re-dispatching that same operation
+            // before the publication retry only rediscovers the prerequisite
+            // and prevents the retry from ever executing.
+            await bundle.runner.retryDue();
+            const postRetryCheckpoint = bundle.runner.readStatus().checkpoint?.checkpoint;
+            const postRetryState = this.host.readState();
+            if (wakeEpoch === this.ordinaryWakeEpoch
+                && postRetryCheckpoint?.syncEnabled
+                && postRetryCheckpoint.retry?.kind !== 'v2-content-push'
+                && postRetryState.ownershipMode === 'server'
+                && postRetryState.transitionState === 'idle'
+                && postRetryState.activeWorkspaceId === bundle.context.workspaceId
+                && postRetryState.coordinatorGeneration
+                    === bundle.context.coordinatorGeneration) {
+                const postPublicationDrain = await this.drainOutbox(bundle.outbox, bundle.runner);
+                if (postPublicationDrain === 'pull-required') {
+                    await this.runFairnessPull(bundle);
+                }
+            }
+            return;
+        }
+        const preDrain = retryDue
+            ? await this.drainMigrationOutbox(bundle.outbox, bundle.runner)
+            : await this.drainOutbox(bundle.outbox, bundle.runner, undefined, undefined, coordinatorRecoveryPlan.total > 0);
+        if (preDrain === 'v2-content-push-required') {
+            await bundle.runner.pushContentPrerequisiteDue();
+            return;
+        }
+        if (preDrain === 'pull-required') {
+            await this.runFairnessPull(bundle);
+            return;
+        }
+        if (preDrain === 'budget-exhausted') {
+            this.pendingWakeSources.add('outbox');
+            return;
+        }
+        if (preDrain === 'command-pending' || preDrain === 'disabled')
+            return;
+        const state = this.host.readState();
+        if (wakeEpoch !== this.ordinaryWakeEpoch
+            || state.ownershipMode !== 'server'
+            || state.transitionState !== 'idle'
+            || state.activeWorkspaceId !== bundle.context.workspaceId
+            || state.coordinatorGeneration !== bundle.context.coordinatorGeneration) {
+            return;
+        }
+        if (retryDue) {
+            await bundle.runner.retryDue();
+        }
+        else if (wakeSources.size === 1
+            && wakeSources.has('realtime')
+            && coordinatorRecoveryPlan.total === 0) {
+            // A realtime notification means cloud state may have advanced. A
+            // full inspection also pushes local V2 state, which emits another
+            // realtime notification and can create a self-sustaining
+            // push -> realtime -> sync loop even when the local outbox is
+            // empty. A pure realtime wake therefore only consumes the remote
+            // hint with a pull when no coordinator recovery is open. Recovery
+            // obligations require the full inspection path so it can promote
+            // the cycle into authoritative Repair and settle them.
+            await bundle.runner.pullDue();
+            return;
+        }
+        else {
+            await bundle.runner.inspect();
+        }
+        if (wakeEpoch === this.ordinaryWakeEpoch
+            && bundle.runner.readStatus().checkpoint?.checkpoint.syncEnabled) {
+            const postDrain = await this.drainOutbox(bundle.outbox, bundle.runner);
+            if (postDrain === 'pull-required') {
+                await this.runFairnessPull(bundle);
+            }
+        }
+    }
+    async runFairnessPull(bundle) {
+        await bundle.runner.pullDue();
+        const drainResult = await this.drainOutbox(bundle.outbox, bundle.runner);
+        if (drainResult === 'pull-required') {
+            await bundle.runner.pullDue();
+            return;
+        }
+        if (drainResult === 'drained') {
+            if (await this.promotePendingRemoteHint(bundle.runner)) {
+                await bundle.runner.pullDue();
+                return;
+            }
+            await bundle.runner.pushDue();
+        }
+    }
+    async shutdown(graceMs = this.options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS) {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.shuttingDown = true;
+        this.pendingWakeSources.clear();
+        this.pendingRemoteHintObservedAt = null;
+        this.pendingCommand = null;
+        this.offMutationWake?.();
+        this.offMutationWake = null;
+        this.offRealtimeWakeSuppression?.();
+        this.offRealtimeWakeSuppression = null;
+        this.shutdownPromise = (async () => {
+            this.host.closeCommandIntake();
+            this.stopPeriodicWake();
+            this.runnerBundle?.outbox.closeIntake();
+            const deadline = Date.now() + Math.max(0, Math.floor(graceMs));
+            const remaining = () => Math.max(0, deadline - Date.now());
+            const transitionsDrained = await this.host.waitForTransitionDrain(remaining());
+            if (!transitionsDrained) {
+                throw new Error('The local sync coordinator transition did not drain before shutdown.');
+            }
+            await this.awaitRunnerInitialization(remaining());
+            const bundle = this.runnerBundle;
+            if (bundle) {
+                await bundle.runner.drain(remaining());
+                await bundle.outbox.drain(remaining());
+                await this.ownershipDrain.drain({
+                    workspaceId: bundle.context.workspaceId,
+                    sourceGeneration: bundle.context.coordinatorGeneration,
+                    graceMs: remaining(),
+                });
+                await bundle.runner.stop();
+                this.runnerBundle = null;
+            }
+            else {
+                await Promise.all([
+                    this.transportGateway.drain(remaining()),
+                    this.dispatchTracker.drain(remaining()),
+                ]);
+            }
+            this.credentialBroker.clear('server-shutdown');
+            this.host.completeShutdownAfterExternalDrain();
+        })();
+        return this.shutdownPromise;
+    }
+    async awaitRunnerInitialization(graceMs) {
+        const initialization = this.runnerInitializationPromise;
+        if (!initialization)
+            return;
+        let timer;
+        try {
+            try {
+                await Promise.race([
+                    initialization.then(() => undefined),
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => {
+                            reject(new Error('The server sync runner did not finish initializing before shutdown.'));
+                        }, Math.max(0, Math.floor(graceMs)));
+                        timer.unref?.();
+                    }),
+                ]);
+            }
+            catch (error) {
+                if (error?.code
+                    !== RUNNER_INITIALIZATION_ABORTED_BY_SHUTDOWN) {
+                    throw error;
+                }
+            }
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async releaseProcessLock() {
+        if (!this.shutdownPromise) {
+            throw new Error('The server sync process lock cannot be released before shutdown completes.');
+        }
+        await this.shutdownPromise;
+        await this.host.releaseProcessLock();
+    }
+    createOwnershipLifecycle() {
+        return {
+            prepareTransfer: async () => {
+                if (this.shuttingDown)
+                    throw new Error('The server sync runtime is shutting down.');
+                await this.runnerInitializationPromise;
+            },
+            drainCurrentOwner: async (context, graceMs) => {
+                const deadline = Date.now() + Math.max(0, Math.floor(graceMs));
+                const remaining = () => Math.max(0, deadline - Date.now());
+                if (context.sourceMode === 'server') {
+                    const bundle = this.requireBundle(context.workspaceId, context.sourceGeneration);
+                    bundle.outbox.closeIntake();
+                    await bundle.runner.drain(remaining());
+                    await bundle.outbox.drain(remaining());
+                }
+                await this.ownershipDrain.drain({
+                    workspaceId: context.workspaceId,
+                    sourceGeneration: context.sourceGeneration,
+                    graceMs: remaining(),
+                });
+            },
+            advanceCredentialGeneration: async (context) => {
+                this.credentialBroker.advanceCoordinatorGenerationForOwnershipTransfer({
+                    workspaceId: context.workspaceId,
+                    fromCoordinatorGeneration: context.sourceGeneration,
+                    toCoordinatorGeneration: context.targetGeneration,
+                });
+            },
+            prepareServerRunner: async (context) => {
+                const snapshot = this.credentialBroker.requireCapability({
+                    workspaceId: context.workspaceId,
+                    coordinatorGeneration: context.targetGeneration,
+                });
+                const runnerContext = {
+                    tenantId: snapshot.validation.principal.tenantId,
+                    workspaceId: context.workspaceId,
+                    coordinatorGeneration: context.targetGeneration,
+                };
+                const bundle = this.createRunnerBundle(runnerContext);
+                await bundle.runner.prepare(runnerContext);
+                this.runnerBundle = bundle;
+            },
+            activateServerRunnerForCommit: (context) => {
+                const bundle = this.requireBundle(context.workspaceId, context.targetGeneration);
+                bundle.runner.activate();
+                this.startPeriodicWake();
+                this.requestWake('activation');
+            },
+            stopServerRunner: async (context) => {
+                const bundle = this.runnerBundle;
+                if (!bundle)
+                    return;
+                if (bundle.context.workspaceId !== context.workspaceId
+                    || ![context.sourceGeneration, context.targetGeneration]
+                        .includes(bundle.context.coordinatorGeneration)) {
+                    throw new Error('The prepared server runner does not match the ownership transfer.');
+                }
+                this.stopPeriodicWake();
+                this.pendingWakeSources.clear();
+                this.pendingRemoteHintObservedAt = null;
+                this.pendingCommand = null;
+                bundle.outbox.closeIntake();
+                await bundle.runner.stop();
+                this.runnerBundle = null;
+            },
+        };
+    }
+    createRunnerBundle(context) {
+        this.permitStore.recoverPriorServerPermits({
+            currentServerInstanceId: this.host.serverInstanceId,
+            workspaceId: context.workspaceId,
+        });
+        const remoteServices = createServerWorkspaceSyncEngineRemoteServices({
+            workspaceId: context.workspaceId,
+            coordinatorGeneration: context.coordinatorGeneration,
+            serverInstanceId: this.host.serverInstanceId,
+            permitStore: this.permitStore,
+            transportGateway: this.transportGateway,
+            now: this.now,
+        });
+        const snapshotReader = createWorkspaceSyncEngineServerSnapshotReader({
+            core: this.options.core,
+            contentSyncState: {
+                listWorkspaceSyncDocumentIndex: (basePath, workspaceId) => this.options.serverDataServices.contentSyncState
+                    .listWorkspaceSyncDocumentIndex(basePath, workspaceId),
+                listWorkspaceSyncDocumentsSnapshot: async (basePath, workspaceId) => (await this.options.serverDataServices.contentSyncState
+                    .listWorkspaceSyncDocumentsSnapshot(basePath, workspaceId)).map((document) => ({
+                    ...document,
+                    linkRole: document.linkRole === 'reference'
+                        ? 'reference'
+                        : 'attachment',
+                })),
+                listWorkspaceSyncBinaryAssetIndex: (workspaceId) => this.options.serverDataServices.contentSyncState
+                    .listWorkspaceSyncBinaryAssetIndex(workspaceId),
+                listWorkspaceSyncBinaryAssetsSnapshot: (basePath, workspaceId) => this.options.serverDataServices.contentSyncState
+                    .listWorkspaceSyncBinaryAssetsSnapshot(basePath, workspaceId),
+            },
+            collaborationSyncState: this.options.serverDataServices.collaborationSyncState,
+        });
+        const durabilityStore = new WorkspaceSyncDurabilityStore(this.options.core.getDatabaseAdapter());
+        const outbox = new LocalWorkspaceSyncServerOutboxDispatcher({
+            workspaceId: context.workspaceId,
+            coordinatorGeneration: context.coordinatorGeneration,
+            serverInstanceId: this.host.serverInstanceId,
+            core: this.options.core,
+            coordinatorStore: this.coordinatorStore,
+            permitStore: this.permitStore,
+            transportGateway: this.transportGateway,
+            dispatchTracker: this.dispatchTracker,
+            durabilityStore,
+            env: this.options.env,
+            now: this.now,
+            recordCommittedAuthoritativeApply: () => {
+                this.coordinatorStore.advanceLocalDataVersion({
+                    workspaceId: context.workspaceId,
+                    expectedCoordinatorGeneration: context.coordinatorGeneration,
+                });
+            },
+            recordTransferEvidence: (evidence) => {
+                this.options.core.recordSyncEventDurably(context.workspaceId, workspaceSyncTransferEvidenceEvent(evidence));
+            },
+        });
+        const drainV3Outbox = async (input) => {
+            const result = await this.drainOutbox(outbox, undefined, input.beforeTransport);
+            return result === 'v2-content-push-required' || result === 'budget-exhausted'
+                ? result
+                : 'drained';
+        };
+        const inspectRepairableCoordinatorObligations = () => this.permitStore.inspectAuthoritativeRepairRecoveryObligations(context.workspaceId);
+        const operations = createWorkspaceSyncEngineServerRunnerOperations({
+            workspaceId: context.workspaceId,
+            remoteServices,
+            pushCandidateProvider: createWorkspaceSyncEngineServerPushCandidateProvider(snapshotReader),
+            resolveV2ContentPrerequisitePaths: ({ workspaceId }) => {
+                const documentPaths = new Set();
+                const assetPaths = new Set();
+                for (const assetId of durabilityStore
+                    .listAttachmentAssetIdsAwaitingContentPublication({
+                    tenantId: this.options.core.getTenantId(),
+                    workspaceId,
+                })) {
+                    const asset = this.options.serverDataServices.workspaceAssetStore
+                        ?.get(assetId, workspaceId);
+                    if (!asset || asset.deletedAt || asset.storageProvider === 'external')
+                        continue;
+                    if (asset.kind === 'document') {
+                        const normalized = this.options.serverDataServices
+                            .normalizeWorkspaceSyncDocumentPath(asset.storageKey);
+                        if (normalized)
+                            documentPaths.add(normalized);
+                        continue;
+                    }
+                    const normalized = normalizeTaskDataRelativePath(asset.storageKey);
+                    if (normalized)
+                        assetPaths.add(normalized);
+                }
+                return { documentPaths, assetPaths };
+            },
+            drainV3Outbox,
+            inspectV3Outbox: () => readWorkspaceSyncV3LocalOutboxStatus({
+                db: this.options.core.getDatabaseAdapter(),
+                tenantId: this.options.core.getTenantId(),
+                workspaceId: context.workspaceId,
+                now: this.now().toISOString(),
+            }),
+            recordSuppressedRealtimeEventIds: (eventIds) => {
+                for (const rawEventId of eventIds) {
+                    const eventId = String(rawEventId || '').trim();
+                    if (!eventId || this.suppressedRealtimeEventIds.has(eventId))
+                        continue;
+                    this.suppressedRealtimeEventIds.add(eventId);
+                    this.suppressedRealtimeEventIdQueue.push(eventId);
+                }
+                while (this.suppressedRealtimeEventIdQueue.length > 4096) {
+                    const staleEventId = this.suppressedRealtimeEventIdQueue.shift();
+                    if (staleEventId)
+                        this.suppressedRealtimeEventIds.delete(staleEventId);
+                }
+            },
+            attachmentApply: {
+                processDue: async ({ limit, hydrateAsset }) => {
+                    const result = await resolveWorkspaceSyncV3AttachmentApplyObligations({
+                        core: this.options.core,
+                        workspaceId: context.workspaceId,
+                        now: this.now().toISOString(),
+                        limit,
+                        hydrateAsset,
+                        onInstalled: () => {
+                            this.coordinatorStore.advanceLocalDataVersion({
+                                workspaceId: context.workspaceId,
+                                expectedCoordinatorGeneration: context.coordinatorGeneration,
+                            });
+                        },
+                    });
+                    if (result.resolvedTaskIds.length > 0) {
+                        this.options.core.notifyWorkspaceSyncV3TaskRootsCommitted(context.workspaceId, { upsertIds: result.resolvedTaskIds, deleteIds: [] });
+                    }
+                    return result;
+                },
+            },
+            coordinatorRecovery: {
+                inspectRepairableObligations: inspectRepairableCoordinatorObligations,
+                completeAuthoritativeRepair: (input) => {
+                    const outboxStatus = readWorkspaceSyncV3LocalOutboxStatus({
+                        db: this.options.core.getDatabaseAdapter(),
+                        tenantId: this.options.core.getTenantId(),
+                        workspaceId: context.workspaceId,
+                        now: this.now().toISOString(),
+                    });
+                    if (outboxStatus.activeDepth !== 0 || outboxStatus.recovery) {
+                        throw Object.assign(new Error('Authoritative repair completion requires a fully drained durable outbox.'), { code: 'SYNC_COORDINATOR_PERMIT_STATE_CONFLICT' });
+                    }
+                    const result = this.permitStore.resolveAuthoritativeRepairRecoveryObligations({
+                        workspaceId: context.workspaceId,
+                        coordinatorGeneration: context.coordinatorGeneration,
+                        ownerMode: 'server',
+                        repairId: input.repairId,
+                        stateSignatureSha256: input.stateSignatureSha256,
+                    });
+                    return {
+                        resolved: result.resolved,
+                        remainingRepairable: inspectRepairableCoordinatorObligations().total,
+                    };
+                },
+            },
+            now: this.now,
+            recordTransferEvidence: (evidence, errorMessage) => {
+                this.options.core.recordSyncEventDurably(context.workspaceId, workspaceSyncTransferEvidenceEvent(evidence, errorMessage));
+            },
+            resolveV3Ownership: ({ workspaceId }) => {
+                const ownership = readWorkspaceSyncLocalOwnershipSnapshot({
+                    core: this.options.core,
+                    workspaceId,
+                });
+                const combined = ownership.combinedProjection;
+                const combinedContract = combined.owner === 'v3'
+                    ? resolveWorkspaceSyncV3CombinedWireContract(combined)
+                    : null;
+                if (combined.owner === 'v3' && !combinedContract) {
+                    throw Object.assign(new Error('The persisted combined-feed ownership contract is invalid.'), { code: 'SYNC_RUNNER_V3_OWNERSHIP_INVALID' });
+                }
+                return {
+                    initiativeFeedActivationEnabled: ownership.initiativeProjection.owner === 'v3',
+                    initiativeProjection: ownership.initiativeProjection,
+                    combinedFeedActivationEnabled: combined.owner === 'v3',
+                    combinedProjection: combined,
+                    ...(combinedContract
+                        ? {
+                            combinedFeedCoverage: combinedContract.coverage,
+                            combinedFeedExcludedProjections: combinedContract.excludedProjections,
+                        }
+                        : {}),
+                };
+            },
+            createLocalServices: ({ checkpointPort }) => {
+                const boundary = createWorkspaceSyncEngineServerApplyBoundary({
+                    checkpointPort,
+                    permitStore: this.permitStore,
+                    recordCommittedLocalApply: (applyResult) => {
+                        if (!shouldAdvanceLocalDataVersion(applyResult))
+                            return;
+                        this.coordinatorStore.advanceLocalDataVersion({
+                            workspaceId: context.workspaceId,
+                            expectedCoordinatorGeneration: context.coordinatorGeneration,
+                        });
+                    },
+                });
+                return createServerWorkspaceSyncEngineLocalServices({
+                    core: this.options.core,
+                    contentSyncState: this.options.serverDataServices.contentSyncState,
+                    workspaceAssetStore: this.options.serverDataServices.workspaceAssetStore,
+                    hasObjectStorageClient: this.options.serverDataServices.hasObjectStorageClient,
+                    immutableContentStager: this.options.contentRuntime.immutableContentStager,
+                    contentVersionStore: this.options.serverDataServices.contentVersionStore,
+                    contentLifecycle: this.options.contentRuntime.contentLifecycle,
+                    normalizeWorkspaceSyncDocumentPath: this.options.serverDataServices.normalizeWorkspaceSyncDocumentPath,
+                    recordSyncDiagnostic: this.options.serverDataServices.recordSyncDiagnostic,
+                    resolveCombinedApplyTransactionHooks: boundary.resolveCombinedApplyTransactionHooks,
+                    resolveV3ApplyTransactionHooks: boundary.resolveV3ApplyTransactionHooks,
+                    resolveV2ApplyTransactionHooks: boundary.resolveV2ApplyTransactionHooks,
+                    completeV2PushApply: boundary.completeV2PushApply,
+                    now: this.now,
+                });
+            },
+        });
+        const runner = new LocalWorkspaceSyncRunner({
+            coordinatorStore: this.coordinatorStore,
+            runnerStateStore: this.runnerStateStore,
+            credentialBroker: this.credentialBroker,
+            operations,
+            recoverBeforeStart: async () => {
+                this.permitStore.recoverPriorServerPermits({
+                    currentServerInstanceId: this.host.serverInstanceId,
+                    workspaceId: context.workspaceId,
+                });
+            },
+            now: () => this.now().toISOString(),
+            setTimer: this.setTimer,
+            clearTimer: this.clearTimer,
+            defaultDrainGraceMs: this.options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS,
+            requestScheduledRetryWake: (retryContext) => {
+                this.requestWake('retry', {
+                    workspaceId: retryContext.workspaceId,
+                    coordinatorGeneration: retryContext.coordinatorGeneration,
+                });
+            },
+            reportInternalError: (error, source) => this.options.reportInternalError?.(error, source),
+        });
+        return { context, runner, outbox };
+    }
+    onCommandAccepted(command) {
+        if (!this.runnerBundle || command.workspaceId !== this.runnerBundle.context.workspaceId)
+            return;
+        if (command.type === 'DisableSync') {
+            this.ordinaryWakeEpoch += 1;
+            this.pendingWakeSources.clear();
+            this.pendingRemoteHintObservedAt = null;
+            this.pendingCommand = null;
+        }
+        this.pendingCommand = command;
+        this.requestWake('command', {
+            workspaceId: command.workspaceId,
+            coordinatorGeneration: command.expectedCoordinatorGeneration,
+        });
+    }
+    startPeriodicWake() {
+        this.stopPeriodicWake();
+        const schedule = () => {
+            if (this.shuttingDown || !this.runnerBundle)
+                return;
+            this.periodicWakeTimer = this.setTimer(() => {
+                this.periodicWakeTimer = null;
+                this.requestWake('periodic');
+                schedule();
+            }, this.options.periodicWakeMs ?? DEFAULT_PERIODIC_WAKE_MS);
+            this.periodicWakeTimer.unref?.();
+        };
+        schedule();
+    }
+    stopPeriodicWake() {
+        if (!this.periodicWakeTimer)
+            return;
+        this.clearTimer(this.periodicWakeTimer);
+        this.periodicWakeTimer = null;
+    }
+    requireBundle(workspaceId, generation) {
+        const bundle = this.runnerBundle;
+        if (!bundle
+            || bundle.context.workspaceId !== workspaceId
+            || bundle.context.coordinatorGeneration !== generation) {
+            throw new Error('The expected server sync runner is not prepared.');
+        }
+        return bundle;
+    }
+    async drainOutbox(outbox, fairnessRunner, beforeTransport, ignoreAcceptedCommandId, ignorePullFairness = false) {
+        const deadline = Date.now()
+            + (this.options.outboxDrainBudgetMs ?? DEFAULT_OUTBOX_DRAIN_BUDGET_MS);
+        for (;;) {
+            if (!fairnessRunner) {
+                const result = await outbox.dispatchOnce({ beforeTransport });
+                if (result.outcomes.some((outcome) => outcome.schedulerAction === 'v2-content-push-required')) {
+                    return 'v2-content-push-required';
+                }
+                if (result.claimed === 0)
+                    return 'drained';
+                if (Date.now() >= deadline)
+                    return 'budget-exhausted';
+                continue;
+            }
+            await this.promotePendingRemoteHint(fairnessRunner);
+            const scheduled = await fairnessRunner.dispatchPushWithFairness((beforeTransport) => outbox.dispatchOnce({ beforeTransport }), { ignoreAcceptedCommandId, ignorePullFairness });
+            if (scheduled.kind !== 'dispatched')
+                return scheduled.kind;
+            if (scheduled.result.outcomes.some((outcome) => outcome.schedulerAction === 'v2-content-push-required')) {
+                return 'v2-content-push-required';
+            }
+            if (scheduled.result.claimed === 0)
+                return 'drained';
+            if (Date.now() >= deadline)
+                return 'budget-exhausted';
+        }
+    }
+    async drainMigrationOutbox(outbox, fairnessRunner, ignoreAcceptedCommandId) {
+        const deadline = Date.now()
+            + (this.options.migrationOutboxDrainBudgetMs
+                ?? DEFAULT_MIGRATION_OUTBOX_DRAIN_BUDGET_MS);
+        for (;;) {
+            const scheduled = await fairnessRunner.dispatchPushWithFairness((beforeTransport) => outbox.dispatchMigrationOnce({ beforeTransport }), {
+                ignoreAcceptedCommandId,
+                ignorePullFairness: true,
+            });
+            if (scheduled.kind !== 'dispatched')
+                return scheduled.kind;
+            if (scheduled.result.outcomes.some((outcome) => outcome.schedulerAction === 'v2-content-push-required')) {
+                return 'v2-content-push-required';
+            }
+            if (scheduled.result.claimed === 0)
+                return 'drained';
+            if (Date.now() >= deadline)
+                return 'budget-exhausted';
+        }
+    }
+    async promotePendingRemoteHint(runner) {
+        const observedAt = this.pendingRemoteHintObservedAt;
+        if (!observedAt)
+            return false;
+        const consumedSources = [...REMOTE_PULL_WAKE_SOURCES]
+            .filter((source) => this.pendingWakeSources.has(source));
+        this.pendingRemoteHintObservedAt = null;
+        for (const source of consumedSources) {
+            this.pendingWakeSources.delete(source);
+        }
+        try {
+            await runner.observeRemoteHint(observedAt);
+        }
+        catch (error) {
+            if (!this.pendingRemoteHintObservedAt
+                || Date.parse(observedAt) < Date.parse(this.pendingRemoteHintObservedAt)) {
+                this.pendingRemoteHintObservedAt = observedAt;
+            }
+            for (const source of consumedSources) {
+                this.pendingWakeSources.add(source);
+            }
+            throw error;
+        }
+        return true;
+    }
+    contextFor(state, credential) {
+        if (!state.activeWorkspaceId
+            || credential.status !== 'ready'
+            || !credential.principal) {
+            throw new Error('A matching authenticated workspace is required to create the server runner.');
+        }
+        return {
+            tenantId: credential.principal.tenantId,
+            workspaceId: state.activeWorkspaceId,
+            coordinatorGeneration: state.coordinatorGeneration,
+        };
+    }
+    assertCompositionInputs() {
+        if (!this.options.processLock.owned) {
+            throw new Error('The dark server sync runtime requires the owned process lock.');
+        }
+        if (!this.options.serverDataServices.workspaceAssetStore
+            || !this.options.serverDataServices.contentVersionStore) {
+            throw new Error('The server sync runtime requires database-backed content services.');
+        }
+    }
+}
+export function createLocalWorkspaceSyncServerRuntime(options) {
+    return new LocalWorkspaceSyncServerRuntime(options);
+}