velocious 1.0.671 → 1.0.673

package/build/src/sync/sync-coordinator.js

@@ -0,0 +1,683 @@
+// @ts-check
+import restArgsError from "../utils/rest-args-error.js";
+const COORDINATOR_STATES = new Set(["backoff", "conflicted", "failed", "idle", "offline", "pending", "stopped", "syncing"]);
+const DEFAULT_RETRY = Object.freeze({ initialDelayMs: 1_000, maxAttempts: 4, maxDelayMs: 30_000 });
+/** Expected cooperative cancellation raised by a SyncCoordinator lifecycle transition. */
+export class SyncCoordinatorLifecycleAbortError extends Error {
+    /**
+     * Creates a lifecycle cancellation error.
+     * @param {string} message - Cancellation reason.
+     */
+    constructor(message) {
+        super(message);
+        this.name = "SyncCoordinatorLifecycleAbortError";
+    }
+}
+/**
+ * Reusable observable lifecycle around SyncClient. It serializes replay,
+ * realtime subscription, and stable-cursor pull into one cycle; coalesces any
+ * triggers received during that cycle into one rerun; owns bounded retry; and
+ * generation-fences status updates after stop/restart.
+ */
+export default class SyncCoordinator {
+    /**
+     * Creates one reusable sync lifecycle owner.
+     * @param {object} args - Coordinator dependencies.
+     * @param {(error: Error) => {code: string, message?: string, retryable: boolean}} [args.classifyError] - Maps errors to safe retry/display metadata. Defaults to permanent `sync_failed` without persisting the error message.
+     * @param {import("./sync-coordinator-types.js").SyncCoordinatorConnectivity} [args.connectivity] - Optional connectivity event source.
+     * @param {() => Date} [args.now] - Injected clock.
+     * @param {(args: {signal: AbortSignal, syncClient: import("./sync-client.js").default}) => Promise<(() => Promise<void> | void) | void> | (() => Promise<void> | void) | void} [args.prepare] - Activates scopes/acquires app-owned resources before the first cycle and returns their teardown.
+     * @param {boolean} [args.realtime] - Whether cycles subscribe realtime before pulling. Defaults to true.
+     * @param {{initialDelayMs?: number, maxAttempts?: number, maxDelayMs?: number}} [args.retry] - Bounded automatic retry policy.
+     * @param {import("./sync-coordinator-types.js").SyncCoordinatorScheduler} [args.scheduler] - Injected timer owner.
+     * @param {import("./sync-coordinator-types.js").SyncCoordinatorStatusStore} [args.statusStore] - Optional privacy-safe durable status store.
+     * @param {import("./sync-client.js").default} args.syncClient - SyncClient owning queue, scopes, cursors, apply, and realtime.
+     */
+    constructor({ classifyError = defaultErrorClassification, connectivity, now = () => new Date(), prepare = () => undefined, realtime = true, retry = {}, scheduler = defaultScheduler(), statusStore, syncClient, ...restArgs }) {
+        restArgsError(restArgs);
+        requireCoordinatorClient(syncClient);
+        requireFunction(classifyError, "classifyError");
+        requireFunction(now, "now");
+        requireFunction(prepare, "prepare");
+        if (typeof realtime !== "boolean")
+            throw new Error("SyncCoordinator realtime must be boolean");
+        if (connectivity)
+            requireFunction(connectivity.subscribe, "connectivity.subscribe");
+        if (statusStore) {
+            requireFunction(statusStore.load, "statusStore.load");
+            requireFunction(statusStore.save, "statusStore.save");
+        }
+        requireFunction(scheduler.clearTimeout, "scheduler.clearTimeout");
+        requireFunction(scheduler.setTimeout, "scheduler.setTimeout");
+        this.syncClient = syncClient;
+        this.classifyError = classifyError;
+        this.connectivity = connectivity || null;
+        this.now = now;
+        this.prepare = prepare;
+        this.realtime = realtime;
+        this.retryPolicy = normalizeRetryPolicy(retry);
+        this.scheduler = scheduler;
+        this.statusStore = statusStore || null;
+        this._active = false;
+        this._attempt = 0;
+        this._generation = 0;
+        this._lifecycleAbortController = new AbortController();
+        /** @type {Set<(status: import("./sync-coordinator-types.js").SyncCoordinatorStatus) => void>} */
+        this._listeners = new Set();
+        /** @type {Array<() => Promise<void> | void>} */
+        this._lifecycleCleanups = [];
+        /** @type {Promise<void> | null} */
+        this._runPromise = null;
+        this._rerunRequested = false;
+        /** @type {unknown} */
+        this._retryTimer = null;
+        /** @type {Promise<void> | null} */
+        this._startPromise = null;
+        /** @type {Promise<void> | null} */
+        this._stopPromise = null;
+        /** @type {import("./sync-coordinator-types.js").SyncCoordinatorStatus} */
+        this._status = immutableStatus({
+            conflicts: [],
+            failure: null,
+            lastSuccessAt: null,
+            nextRetryAt: null,
+            pendingCount: 0,
+            rejectedCount: 0,
+            state: "stopped"
+        });
+    }
+    /**
+     * Installs local ownership and schedules the initial network cycle without
+     * awaiting it, so cached reads never depend on network completion.
+     * @returns {Promise<void>} - Resolves after local ownership is installed.
+     */
+    start() {
+        if (this._active && !this._startPromise)
+            return Promise.resolve();
+        if (this._startPromise)
+            return this._startPromise;
+        if (this._stopPromise)
+            return this._stopPromise.then(async () => await this.start());
+        this._active = true;
+        this._attempt = 0;
+        const generation = ++this._generation;
+        this._lifecycleAbortController = new AbortController();
+        this._startPromise = this._start(generation).finally(() => {
+            this._startPromise = null;
+        });
+        return this._startPromise;
+    }
+    /**
+     * Starts one lifecycle generation with rollback on failure.
+     * @param {number} generation - Owning generation.
+     * @returns {Promise<void>} - Resolves after activation completes.
+     */
+    async _start(generation) {
+        try {
+            await this._activate(generation);
+        }
+        catch (error) {
+            if (this.isLifecycleAbort(error) || !this._ownsGeneration(generation))
+                throw error;
+            await this._rollbackFailedStart(/** @type {Error} */ (error), generation);
+        }
+    }
+    /**
+     * Acquires coordinator, connectivity, client, and application resources.
+     * @param {number} generation - Owning generation.
+     * @returns {Promise<void>} - Resolves after every owner is active.
+     */
+    async _activate(generation) {
+        if (this.statusStore) {
+            const persistedStatus = await this.statusStore.load();
+            this._assertActive(generation);
+            if (persistedStatus)
+                this._publish(restoredStatus(persistedStatus));
+        }
+        const detachCoordinator = this.syncClient.attachCoordinator(async (reason) => await this.trigger(reason));
+        this._lifecycleCleanups.push(detachCoordinator);
+        if (this.connectivity) {
+            const unsubscribeConnectivity = this.connectivity.subscribe((online) => this._connectivityChanged({ generation, online }));
+            this._lifecycleCleanups.push(unsubscribeConnectivity);
+        }
+        this._assertActive(generation);
+        await this.syncClient.start();
+        this._assertActive(generation);
+        const release = await this.prepare({ signal: this._lifecycleAbortController.signal, syncClient: this.syncClient });
+        if (release !== undefined)
+            requireFunction(release, "prepare teardown");
+        if (!this._ownsGeneration(generation)) {
+            if (release)
+                await release();
+            throw new SyncCoordinatorLifecycleAbortError("Sync coordinator stopped during preparation");
+        }
+        if (release)
+            this._lifecycleCleanups.push(release);
+        this._rerunRequested = true;
+        void this._startRequestedRun();
+    }
+    /**
+     * Releases every partially acquired owner after a failed start, publishes a
+     * safe terminal failure, and rethrows the original error (or an aggregate if
+     * teardown also failed).
+     * @param {Error} error - Start failure.
+     * @param {number} generation - Failed generation.
+     * @returns {Promise<never>} - Always rejects with the start or aggregate error.
+     */
+    async _rollbackFailedStart(error, generation) {
+        this._active = false;
+        this._generation += 1;
+        this._lifecycleAbortController.abort(new SyncCoordinatorLifecycleAbortError("Sync coordinator start failed"));
+        this._rerunRequested = false;
+        this._clearRetryTimer();
+        /** @type {unknown[]} */
+        const teardownErrors = [];
+        const cleanups = this._lifecycleCleanups.splice(0).reverse();
+        try {
+            await this.syncClient.stop();
+        }
+        catch (stopError) {
+            teardownErrors.push(stopError);
+        }
+        for (const cleanup of cleanups) {
+            try {
+                await cleanup();
+            }
+            catch (cleanupError) {
+                teardownErrors.push(cleanupError);
+            }
+        }
+        const classified = normalizeErrorClassification(this.classifyError(error));
+        const failure = {
+            attempt: 1,
+            at: this._nowIso(),
+            code: classified.code,
+            ...(classified.message === undefined ? {} : { message: classified.message }),
+            retryable: classified.retryable
+        };
+        this._attempt = 1;
+        this._publish({ ...this._status, failure, nextRetryAt: null, state: "failed" });
+        if (this.statusStore) {
+            try {
+                await this.statusStore.save(this._status);
+            }
+            catch (persistenceError) {
+                teardownErrors.push(persistenceError);
+            }
+        }
+        if (teardownErrors.length > 0)
+            throw new AggregateError([error, ...teardownErrors], `Sync coordinator generation ${generation} failed to start and tear down cleanly`);
+        throw error;
+    }
+    /**
+     * Stops current work, clears timers/listeners, drains SyncClient, and releases
+     * app-owned resources exactly once.
+     * @returns {Promise<void>} - Resolves after the lifecycle is fully stopped.
+     */
+    stop() {
+        if (this._stopPromise)
+            return this._stopPromise;
+        if (!this._active && !this._startPromise && !this._runPromise) {
+            if (this._status.state !== "stopped")
+                this._publish({ ...this._status, nextRetryAt: null, state: "stopped" });
+            return Promise.resolve();
+        }
+        this._active = false;
+        this._generation += 1;
+        this._lifecycleAbortController.abort(new SyncCoordinatorLifecycleAbortError("Sync coordinator was stopped"));
+        this._rerunRequested = false;
+        this._clearRetryTimer();
+        const cleanups = this._lifecycleCleanups.splice(0).reverse();
+        const startPromise = this._startPromise;
+        const runPromise = this._runPromise;
+        this._stopPromise = this._stop({ cleanups, runPromise, startPromise }).finally(() => {
+            this._stopPromise = null;
+        });
+        return this._stopPromise;
+    }
+    /**
+     * Drains captured lifecycle resources after a stop transition.
+     * @param {{cleanups: Array<() => Promise<void> | void>, runPromise: Promise<void> | null, startPromise: Promise<void> | null}} args - Captured generation resources.
+     * @returns {Promise<void>} - Resolves after teardown completes.
+     */
+    async _stop({ cleanups, runPromise, startPromise }) {
+        /** @type {unknown[]} */
+        const errors = [];
+        try {
+            await this.syncClient.stop();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        for (const promise of [startPromise, runPromise]) {
+            if (!promise)
+                continue;
+            try {
+                await promise;
+            }
+            catch (error) {
+                if (!this.isLifecycleAbort(error))
+                    errors.push(error);
+            }
+        }
+        for (const cleanup of cleanups) {
+            try {
+                await cleanup();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        this._attempt = 0;
+        this._publish({ ...this._status, failure: null, nextRetryAt: null, state: "stopped" });
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, "Sync coordinator teardown failed");
+    }
+    /**
+     * Requests a cycle. Overlapping requests share the active flight and produce
+     * at most one queued rerun.
+     * @param {string} [reason] - Diagnostic trigger label (never persisted).
+     * @returns {Promise<void>} - Resolves after the current or queued cycle drains.
+     */
+    trigger(reason = "manual") {
+        void reason;
+        if (!this._active)
+            return Promise.resolve();
+        this._rerunRequested = true;
+        if (this._startPromise) {
+            return this._startPromise.then(async () => await this._startRequestedRun(), () => undefined);
+        }
+        return this._startRequestedRun();
+    }
+    /**
+     * Starts requested work only after lifecycle preparation has completed.
+     * @returns {Promise<void>} - Current or newly started coordinator flight.
+     */
+    _startRequestedRun() {
+        if (!this._active)
+            return Promise.resolve();
+        if (this._retryTimer !== null)
+            return this._runPromise || Promise.resolve();
+        if (!this._runPromise) {
+            const generation = this._generation;
+            this._runPromise = this._drain(generation).finally(() => {
+                this._runPromise = null;
+            });
+        }
+        return this._runPromise;
+    }
+    /**
+     * Clears backoff and requests one single-flight user retry.
+     * @returns {Promise<void>} - Resolves after the retry cycle drains.
+     */
+    retry() {
+        if (!this._active)
+            throw new Error("Cannot retry a stopped SyncCoordinator");
+        this._clearRetryTimer();
+        this._attempt = 0;
+        return this.trigger("manual-retry");
+    }
+    /**
+     * Resolves one durable conflict through SyncClient, then refreshes status and
+     * replays retry-local intent through the same cycle.
+     * @param {{recordId: string, resolution: "keep-server" | "retry-local", resourceType: string}} args - Explicit resolution.
+     * @returns {Promise<void>} - Resolves after resolution state is refreshed.
+     */
+    async resolveConflict(args) {
+        if (!this._active)
+            throw new Error("Cannot resolve a conflict on a stopped SyncCoordinator");
+        await this.syncClient.resolveConflict(args);
+        this._clearRetryTimer();
+        this._attempt = 0;
+        if (args.resolution === "retry-local") {
+            await this.syncClient.waitForScheduledReplay();
+        }
+        else {
+            await this.trigger("conflict-resolution");
+        }
+    }
+    /**
+     * Drains requested work serially for one lifecycle generation.
+     * @param {number} generation - Owning generation.
+     * @returns {Promise<void>} - Resolves when no immediate rerun remains.
+     */
+    async _drain(generation) {
+        while (this._rerunRequested && this._ownsGeneration(generation)) {
+            this._rerunRequested = false;
+            await this._runCycle(generation);
+            if (this._rerunRequested)
+                this._clearRetryTimer();
+        }
+    }
+    /**
+     * Runs one replay, realtime-subscribe, and pull cycle.
+     * @param {number} generation - Owning generation.
+     * @returns {Promise<void>} - Resolves after this cycle settles.
+     */
+    async _runCycle(generation) {
+        try {
+            const online = await this.syncClient.isOnline();
+            this._assertActive(generation);
+            if (!online) {
+                const inspection = await this.syncClient.inspectSyncState();
+                this._assertActive(generation);
+                this._publish({ ...this._status, ...inspection, failure: null, nextRetryAt: null, state: "offline" });
+                await this._persistStatus(generation);
+                return;
+            }
+            this._publish({ ...this._status, nextRetryAt: null, state: "syncing" });
+            await this.syncClient.replayPending();
+            this._assertActive(generation);
+            if (this.realtime) {
+                await this.syncClient.subscribeRealtime();
+                this._assertActive(generation);
+            }
+            await this.syncClient.pull();
+            this._assertActive(generation);
+            const inspection = await this.syncClient.inspectSyncState();
+            this._assertActive(generation);
+            this._publish({
+                ...this._status,
+                ...inspection,
+                failure: null,
+                lastSuccessAt: this._nowIso(),
+                nextRetryAt: null,
+                state: inspectionState(inspection)
+            });
+            await this._persistStatus(generation);
+            this._attempt = 0;
+            return;
+        }
+        catch (error) {
+            if (!this._ownsGeneration(generation) || this.isLifecycleAbort(error) || this.syncClient.isLifecycleAbort(error))
+                return;
+            await this._handleFailure(/** @type {Error} */ (error), generation);
+        }
+    }
+    /**
+     * Publishes a classified failure and owns its bounded retry timer.
+     * @param {Error} error - Cycle failure.
+     * @param {number} generation - Owning generation.
+     * @returns {Promise<void>} - Resolves after status persistence and scheduling.
+     */
+    async _handleFailure(error, generation) {
+        this._attempt += 1;
+        let classified = normalizeErrorClassification(this.classifyError(error));
+        const failedAt = this._nowIso();
+        let failureStatus = failureStatusFor({ attempt: this._attempt, classified, failedAt, retryPolicy: this.retryPolicy, status: this._status });
+        this._publish(failureStatus.status);
+        if (this.statusStore) {
+            try {
+                await this.statusStore.save(this._status);
+                this._assertActive(generation);
+            }
+            catch (persistenceError) {
+                this._assertActive(generation);
+                classified = normalizeErrorClassification(this.classifyError(/** @type {Error} */ (persistenceError)));
+                failureStatus = failureStatusFor({ attempt: this._attempt, classified, failedAt, retryPolicy: this.retryPolicy, status: this._status });
+                this._publish(failureStatus.status);
+            }
+        }
+        if (failureStatus.delayMs !== null) {
+            this._assertActive(generation);
+            this._retryTimer = this.scheduler.setTimeout(() => {
+                this._retryTimer = null;
+                if (!this._ownsGeneration(generation))
+                    return;
+                void this.trigger("automatic-retry");
+            }, failureStatus.delayMs);
+        }
+        this.syncClient.reportError(error);
+    }
+    /**
+     * Persists the current safe status for an active generation.
+     * @param {number} generation - Owning generation.
+     * @returns {Promise<void>} - Resolves after persistence.
+     */
+    async _persistStatus(generation) {
+        if (this.statusStore)
+            await this.statusStore.save(this._status);
+        this._assertActive(generation);
+    }
+    /**
+     * Coalesces one connectivity change into the coordinator cycle.
+     * @param {{generation: number, online: boolean}} args - Connectivity event.
+     * @returns {void}
+     */
+    _connectivityChanged({ generation, online }) {
+        if (!this._ownsGeneration(generation))
+            return;
+        this._clearRetryTimer();
+        if (online)
+            this._attempt = 0;
+        void this.trigger(online ? "connectivity-online" : "connectivity-offline");
+    }
+    /**
+     * Clears the currently owned retry timer, if present.
+     * @returns {void}
+     */
+    _clearRetryTimer() {
+        if (this._retryTimer === null)
+            return;
+        this.scheduler.clearTimeout(this._retryTimer);
+        this._retryTimer = null;
+    }
+    /**
+     * Checks whether a lifecycle generation still owns state updates.
+     * @param {number} generation - Expected generation.
+     * @returns {boolean} - Whether the generation is current and active.
+     */
+    _ownsGeneration(generation) {
+        return this._active && this._generation === generation;
+    }
+    /**
+     * Fails when work no longer belongs to the active generation.
+     * @param {number} generation - Expected generation.
+     * @returns {void}
+     */
+    _assertActive(generation) {
+        if (this._ownsGeneration(generation))
+            return;
+        throw new SyncCoordinatorLifecycleAbortError("Sync coordinator work belongs to an inactive generation");
+    }
+    /**
+     * Identifies coordinator-owned cooperative cancellation.
+     * @param {unknown} error - Candidate error.
+     * @returns {boolean} - Whether this coordinator created the abort error.
+     */
+    isLifecycleAbort(error) {
+        return error instanceof SyncCoordinatorLifecycleAbortError;
+    }
+    /**
+     * Reads and validates the injected clock.
+     * @returns {string} - Valid ISO clock value.
+     */
+    _nowIso() {
+        const value = this.now();
+        if (!(value instanceof Date) || Number.isNaN(value.getTime()))
+            throw new Error("SyncCoordinator now() must return a valid Date");
+        return value.toISOString();
+    }
+    /**
+     * Freezes and publishes a new observable snapshot.
+     * @param {import("./sync-coordinator-types.js").SyncCoordinatorStatus} status - New status.
+     * @returns {void}
+     */
+    _publish(status) {
+        this._status = immutableStatus(status);
+        for (const listener of this._listeners)
+            listener(this._status);
+    }
+    /**
+     * Returns the current observable snapshot.
+     * @returns {import("./sync-coordinator-types.js").SyncCoordinatorStatus} - Current immutable snapshot.
+     */
+    status() {
+        return this._status;
+    }
+    /**
+     * Observes status and receives the current snapshot immediately.
+     * @param {(status: import("./sync-coordinator-types.js").SyncCoordinatorStatus) => void} listener - Observer.
+     * @returns {() => void} - Idempotent unsubscribe.
+     */
+    subscribe(listener) {
+        requireFunction(listener, "status listener");
+        this._listeners.add(listener);
+        listener(this._status);
+        return () => this._listeners.delete(listener);
+    }
+    /**
+     * Awaits only the active or queued cycle, not a future backoff timer.
+     * @returns {Promise<void>} - Resolves when current work drains.
+     */
+    async waitForCurrentRun() {
+        while (this._runPromise)
+            await this._runPromise;
+    }
+}
+/**
+ * Builds the default global timer adapter.
+ * @returns {import("./sync-coordinator-types.js").SyncCoordinatorScheduler} - Global timer adapter.
+ */
+function defaultScheduler() {
+    return {
+        clearTimeout: (timer) => globalThis.clearTimeout(/** @type {ReturnType<typeof setTimeout>} */ (timer)),
+        setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs)
+    };
+}
+/**
+ * Validates and fills retry policy defaults.
+ * @param {Record<string, number>} retry - Retry overrides.
+ * @returns {{initialDelayMs: number, maxAttempts: number, maxDelayMs: number}} - Complete policy.
+ */
+function normalizeRetryPolicy(retry) {
+    const policy = { ...DEFAULT_RETRY, ...retry };
+    for (const [name, value] of Object.entries(policy)) {
+        if (!Number.isInteger(value) || value < 1)
+            throw new Error(`SyncCoordinator retry.${name} must be a positive integer`);
+    }
+    if (policy.maxDelayMs < policy.initialDelayMs)
+        throw new Error("SyncCoordinator retry.maxDelayMs must be greater than or equal to initialDelayMs");
+    return policy;
+}
+/**
+ * Classifies unknown errors as permanent without exposing their messages.
+ * @param {Error} _error - Unclassified error.
+ * @returns {{code: string, retryable: boolean}} - Safe default classification.
+ */
+function defaultErrorClassification(_error) {
+    return { code: "sync_failed", retryable: false };
+}
+/**
+ * Validates application-provided safe error metadata.
+ * @param {ReturnType<typeof defaultErrorClassification> & {message?: string}} classification - Raw classification.
+ * @returns {{code: string, message?: string, retryable: boolean}} - Validated classification.
+ */
+function normalizeErrorClassification(classification) {
+    if (!classification || typeof classification !== "object" || Array.isArray(classification))
+        throw new Error("SyncCoordinator classifyError must return an object");
+    if (typeof classification.code !== "string" || classification.code.length === 0)
+        throw new Error("SyncCoordinator error classification code must be a non-empty string");
+    if (typeof classification.retryable !== "boolean")
+        throw new Error("SyncCoordinator error classification retryable must be boolean");
+    if (classification.message !== undefined && typeof classification.message !== "string")
+        throw new Error("SyncCoordinator error classification message must be a string");
+    return classification;
+}
+/**
+ * Builds one failure snapshot and its optional automatic-retry delay.
+ * @param {{attempt: number, classified: {code: string, message?: string, retryable: boolean}, failedAt: string, retryPolicy: {initialDelayMs: number, maxAttempts: number, maxDelayMs: number}, status: import("./sync-coordinator-types.js").SyncCoordinatorStatus}} args - Failure state.
+ * @returns {{delayMs: number | null, status: import("./sync-coordinator-types.js").SyncCoordinatorStatus}} - Failure snapshot and retry delay.
+ */
+function failureStatusFor({ attempt, classified, failedAt, retryPolicy, status }) {
+    const retryable = classified.retryable && attempt < retryPolicy.maxAttempts;
+    const delayMs = retryable ? Math.min(retryPolicy.initialDelayMs * (2 ** (attempt - 1)), retryPolicy.maxDelayMs) : null;
+    const failure = {
+        attempt,
+        at: failedAt,
+        code: classified.code,
+        ...(classified.message === undefined ? {} : { message: classified.message }),
+        retryable: classified.retryable
+    };
+    const nextRetryAt = delayMs === null ? null : new Date(new Date(failedAt).getTime() + delayMs).toISOString();
+    return {
+        delayMs,
+        status: immutableStatus({ ...status, failure, nextRetryAt, state: retryable ? "backoff" : "failed" })
+    };
+}
+/**
+ * Maps durable queue state to an observable resting state.
+ * @param {import("./sync-coordinator-types.js").SyncClientInspection} inspection - Durable inspection.
+ * @returns {import("./sync-coordinator-types.js").SyncCoordinatorState} - Resting state.
+ */
+function inspectionState(inspection) {
+    if (inspection.conflicts.length > 0)
+        return "conflicted";
+    if (inspection.rejectedCount > 0)
+        return "failed";
+    if (inspection.pendingCount > 0)
+        return "pending";
+    return "idle";
+}
+/**
+ * Removes stale in-flight timing from a restored status snapshot.
+ * @param {import("./sync-coordinator-types.js").SyncCoordinatorStatus} status - Stored status.
+ * @returns {import("./sync-coordinator-types.js").SyncCoordinatorStatus} - Restored observable status.
+ */
+function restoredStatus(status) {
+    if (!COORDINATOR_STATES.has(status.state))
+        throw new Error(`Unknown persisted SyncCoordinator state: ${String(status.state)}`);
+    return {
+        conflicts: status.conflicts,
+        failure: status.failure,
+        lastSuccessAt: status.lastSuccessAt,
+        nextRetryAt: null,
+        pendingCount: status.pendingCount,
+        rejectedCount: status.rejectedCount,
+        state: status.state === "syncing" || status.state === "backoff" ? inspectionState(status) : status.state
+    };
+}
+/**
+ * Deep-freezes the status-owned diagnostic collections.
+ * @param {import("./sync-coordinator-types.js").SyncCoordinatorStatus} status - Snapshot.
+ * @returns {import("./sync-coordinator-types.js").SyncCoordinatorStatus} - Immutable snapshot.
+ */
+function immutableStatus(status) {
+    const conflicts = status.conflicts.map((conflict) => Object.freeze({ ...conflict }));
+    const failure = status.failure ? Object.freeze({ ...status.failure }) : null;
+    return Object.freeze({ ...status, conflicts: Object.freeze(conflicts), failure });
+}
+/**
+ * Validates one required callback.
+ * @param {unknown} value - Function candidate.
+ * @param {string} label - Contract label.
+ * @returns {void} - Validates the function candidate.
+ */
+function requireFunction(value, label) {
+    if (typeof value !== "function")
+        throw new Error(`SyncCoordinator ${label} must be a function`);
+}
+/**
+ * Validates the SyncClient surface required by the coordinator.
+ * @param {import("./sync-client.js").default} client - Client.
+ * @returns {void}
+ */
+function requireCoordinatorClient(client) {
+    if (!client)
+        throw new Error("SyncCoordinator requires a SyncClient");
+    requireFunction(client.attachCoordinator, "syncClient.attachCoordinator");
+    requireFunction(client.inspectSyncState, "syncClient.inspectSyncState");
+    requireFunction(client.isLifecycleAbort, "syncClient.isLifecycleAbort");
+    requireFunction(client.isOnline, "syncClient.isOnline");
+    requireFunction(client.pull, "syncClient.pull");
+    requireFunction(client.reportError, "syncClient.reportError");
+    requireFunction(client.replayPending, "syncClient.replayPending");
+    requireFunction(client.resolveConflict, "syncClient.resolveConflict");
+    requireFunction(client.start, "syncClient.start");
+    requireFunction(client.stop, "syncClient.stop");
+    requireFunction(client.subscribeRealtime, "syncClient.subscribeRealtime");
+    requireFunction(client.waitForScheduledReplay, "syncClient.waitForScheduledReplay");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-coordinator.js","sourceRoot":"","sources":["../../../src/sync/sync-coordinator.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport restArgsError from \"../utils/rest-args-error.js\"\n\nconst COORDINATOR_STATES = new Set([\"backoff\", \"conflicted\", \"failed\", \"idle\", \"offline\", \"pending\", \"stopped\", \"syncing\"])\nconst DEFAULT_RETRY = Object.freeze({initialDelayMs: 1_000, maxAttempts: 4, maxDelayMs: 30_000})\n\n/** Expected cooperative cancellation raised by a SyncCoordinator lifecycle transition. */\nexport class SyncCoordinatorLifecycleAbortError extends Error {\n  /**\n   * Creates a lifecycle cancellation error.\n   * @param {string} message - Cancellation reason.\n   */\n  constructor(message) {\n    super(message)\n    this.name = \"SyncCoordinatorLifecycleAbortError\"\n  }\n}\n\n/**\n * Reusable observable lifecycle around SyncClient. It serializes replay,\n * realtime subscription, and stable-cursor pull into one cycle; coalesces any\n * triggers received during that cycle into one rerun; owns bounded retry; and\n * generation-fences status updates after stop/restart.\n */\nexport default class SyncCoordinator {\n  /**\n   * Creates one reusable sync lifecycle owner.\n   * @param {object} args - Coordinator dependencies.\n   * @param {(error: Error) => {code: string, message?: string, retryable: boolean}} [args.classifyError] - Maps errors to safe retry/display metadata. Defaults to permanent `sync_failed` without persisting the error message.\n   * @param {import(\"./sync-coordinator-types.js\").SyncCoordinatorConnectivity} [args.connectivity] - Optional connectivity event source.\n   * @param {() => Date} [args.now] - Injected clock.\n   * @param {(args: {signal: AbortSignal, syncClient: import(\"./sync-client.js\").default}) => Promise<(() => Promise<void> | void) | void> | (() => Promise<void> | void) | void} [args.prepare] - Activates scopes/acquires app-owned resources before the first cycle and returns their teardown.\n   * @param {boolean} [args.realtime] - Whether cycles subscribe realtime before pulling. Defaults to true.\n   * @param {{initialDelayMs?: number, maxAttempts?: number, maxDelayMs?: number}} [args.retry] - Bounded automatic retry policy.\n   * @param {import(\"./sync-coordinator-types.js\").SyncCoordinatorScheduler} [args.scheduler] - Injected timer owner.\n   * @param {import(\"./sync-coordinator-types.js\").SyncCoordinatorStatusStore} [args.statusStore] - Optional privacy-safe durable status store.\n   * @param {import(\"./sync-client.js\").default} args.syncClient - SyncClient owning queue, scopes, cursors, apply, and realtime.\n   */\n  constructor({classifyError = defaultErrorClassification, connectivity, now = () => new Date(), prepare = () => undefined, realtime = true, retry = {}, scheduler = defaultScheduler(), statusStore, syncClient, ...restArgs}) {\n    restArgsError(restArgs)\n    requireCoordinatorClient(syncClient)\n    requireFunction(classifyError, \"classifyError\")\n    requireFunction(now, \"now\")\n    requireFunction(prepare, \"prepare\")\n    if (typeof realtime !== \"boolean\") throw new Error(\"SyncCoordinator realtime must be boolean\")\n    if (connectivity) requireFunction(connectivity.subscribe, \"connectivity.subscribe\")\n    if (statusStore) {\n      requireFunction(statusStore.load, \"statusStore.load\")\n      requireFunction(statusStore.save, \"statusStore.save\")\n    }\n    requireFunction(scheduler.clearTimeout, \"scheduler.clearTimeout\")\n    requireFunction(scheduler.setTimeout, \"scheduler.setTimeout\")\n\n    this.syncClient = syncClient\n    this.classifyError = classifyError\n    this.connectivity = connectivity || null\n    this.now = now\n    this.prepare = prepare\n    this.realtime = realtime\n    this.retryPolicy = normalizeRetryPolicy(retry)\n    this.scheduler = scheduler\n    this.statusStore = statusStore || null\n\n    this._active = false\n    this._attempt = 0\n    this._generation = 0\n    this._lifecycleAbortController = new AbortController()\n    /** @type {Set<(status: import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus) => void>} */\n    this._listeners = new Set()\n    /** @type {Array<() => Promise<void> | void>} */\n    this._lifecycleCleanups = []\n    /** @type {Promise<void> | null} */\n    this._runPromise = null\n    this._rerunRequested = false\n    /** @type {unknown} */\n    this._retryTimer = null\n    /** @type {Promise<void> | null} */\n    this._startPromise = null\n    /** @type {Promise<void> | null} */\n    this._stopPromise = null\n    /** @type {import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus} */\n    this._status = immutableStatus({\n      conflicts: [],\n      failure: null,\n      lastSuccessAt: null,\n      nextRetryAt: null,\n      pendingCount: 0,\n      rejectedCount: 0,\n      state: \"stopped\"\n    })\n  }\n\n  /**\n   * Installs local ownership and schedules the initial network cycle without\n   * awaiting it, so cached reads never depend on network completion.\n   * @returns {Promise<void>} - Resolves after local ownership is installed.\n   */\n  start() {\n    if (this._active && !this._startPromise) return Promise.resolve()\n    if (this._startPromise) return this._startPromise\n    if (this._stopPromise) return this._stopPromise.then(async () => await this.start())\n\n    this._active = true\n    this._attempt = 0\n    const generation = ++this._generation\n\n    this._lifecycleAbortController = new AbortController()\n    this._startPromise = this._start(generation).finally(() => {\n      this._startPromise = null\n    })\n\n    return this._startPromise\n  }\n\n  /**\n   * Starts one lifecycle generation with rollback on failure.\n   * @param {number} generation - Owning generation.\n   * @returns {Promise<void>} - Resolves after activation completes.\n   */\n  async _start(generation) {\n    try {\n      await this._activate(generation)\n    } catch (error) {\n      if (this.isLifecycleAbort(error) || !this._ownsGeneration(generation)) throw error\n\n      await this._rollbackFailedStart(/** @type {Error} */ (error), generation)\n    }\n  }\n\n  /**\n   * Acquires coordinator, connectivity, client, and application resources.\n   * @param {number} generation - Owning generation.\n   * @returns {Promise<void>} - Resolves after every owner is active.\n   */\n  async _activate(generation) {\n    if (this.statusStore) {\n      const persistedStatus = await this.statusStore.load()\n\n      this._assertActive(generation)\n      if (persistedStatus) this._publish(restoredStatus(persistedStatus))\n    }\n\n    const detachCoordinator = this.syncClient.attachCoordinator(async (reason) => await this.trigger(reason))\n\n    this._lifecycleCleanups.push(detachCoordinator)\n\n    if (this.connectivity) {\n      const unsubscribeConnectivity = this.connectivity.subscribe((online) => this._connectivityChanged({generation, online}))\n\n      this._lifecycleCleanups.push(unsubscribeConnectivity)\n    }\n\n    this._assertActive(generation)\n    await this.syncClient.start()\n    this._assertActive(generation)\n\n    const release = await this.prepare({signal: this._lifecycleAbortController.signal, syncClient: this.syncClient})\n\n    if (release !== undefined) requireFunction(release, \"prepare teardown\")\n    if (!this._ownsGeneration(generation)) {\n      if (release) await release()\n      throw new SyncCoordinatorLifecycleAbortError(\"Sync coordinator stopped during preparation\")\n    }\n    if (release) this._lifecycleCleanups.push(release)\n\n    this._rerunRequested = true\n    void this._startRequestedRun()\n  }\n\n  /**\n   * Releases every partially acquired owner after a failed start, publishes a\n   * safe terminal failure, and rethrows the original error (or an aggregate if\n   * teardown also failed).\n   * @param {Error} error - Start failure.\n   * @param {number} generation - Failed generation.\n   * @returns {Promise<never>} - Always rejects with the start or aggregate error.\n   */\n  async _rollbackFailedStart(error, generation) {\n    this._active = false\n    this._generation += 1\n    this._lifecycleAbortController.abort(new SyncCoordinatorLifecycleAbortError(\"Sync coordinator start failed\"))\n    this._rerunRequested = false\n    this._clearRetryTimer()\n\n    /** @type {unknown[]} */\n    const teardownErrors = []\n    const cleanups = this._lifecycleCleanups.splice(0).reverse()\n\n    try {\n      await this.syncClient.stop()\n    } catch (stopError) {\n      teardownErrors.push(stopError)\n    }\n\n    for (const cleanup of cleanups) {\n      try {\n        await cleanup()\n      } catch (cleanupError) {\n        teardownErrors.push(cleanupError)\n      }\n    }\n\n    const classified = normalizeErrorClassification(this.classifyError(error))\n    const failure = {\n      attempt: 1,\n      at: this._nowIso(),\n      code: classified.code,\n      ...(classified.message === undefined ? {} : {message: classified.message}),\n      retryable: classified.retryable\n    }\n\n    this._attempt = 1\n    this._publish({...this._status, failure, nextRetryAt: null, state: \"failed\"})\n\n    if (this.statusStore) {\n      try {\n        await this.statusStore.save(this._status)\n      } catch (persistenceError) {\n        teardownErrors.push(persistenceError)\n      }\n    }\n\n    if (teardownErrors.length > 0) throw new AggregateError([error, ...teardownErrors], `Sync coordinator generation ${generation} failed to start and tear down cleanly`)\n\n    throw error\n  }\n\n  /**\n   * Stops current work, clears timers/listeners, drains SyncClient, and releases\n   * app-owned resources exactly once.\n   * @returns {Promise<void>} - Resolves after the lifecycle is fully stopped.\n   */\n  stop() {\n    if (this._stopPromise) return this._stopPromise\n    if (!this._active && !this._startPromise && !this._runPromise) {\n      if (this._status.state !== \"stopped\") this._publish({...this._status, nextRetryAt: null, state: \"stopped\"})\n\n      return Promise.resolve()\n    }\n\n    this._active = false\n    this._generation += 1\n    this._lifecycleAbortController.abort(new SyncCoordinatorLifecycleAbortError(\"Sync coordinator was stopped\"))\n    this._rerunRequested = false\n    this._clearRetryTimer()\n\n    const cleanups = this._lifecycleCleanups.splice(0).reverse()\n    const startPromise = this._startPromise\n    const runPromise = this._runPromise\n\n    this._stopPromise = this._stop({cleanups, runPromise, startPromise}).finally(() => {\n      this._stopPromise = null\n    })\n\n    return this._stopPromise\n  }\n\n  /**\n   * Drains captured lifecycle resources after a stop transition.\n   * @param {{cleanups: Array<() => Promise<void> | void>, runPromise: Promise<void> | null, startPromise: Promise<void> | null}} args - Captured generation resources.\n   * @returns {Promise<void>} - Resolves after teardown completes.\n   */\n  async _stop({cleanups, runPromise, startPromise}) {\n    /** @type {unknown[]} */\n    const errors = []\n\n    try {\n      await this.syncClient.stop()\n    } catch (error) {\n      errors.push(error)\n    }\n\n    for (const promise of [startPromise, runPromise]) {\n      if (!promise) continue\n\n      try {\n        await promise\n      } catch (error) {\n        if (!this.isLifecycleAbort(error)) errors.push(error)\n      }\n    }\n\n    for (const cleanup of cleanups) {\n      try {\n        await cleanup()\n      } catch (error) {\n        errors.push(error)\n      }\n    }\n\n    this._attempt = 0\n    this._publish({...this._status, failure: null, nextRetryAt: null, state: \"stopped\"})\n\n    if (errors.length === 1) throw errors[0]\n    if (errors.length > 1) throw new AggregateError(errors, \"Sync coordinator teardown failed\")\n  }\n\n  /**\n   * Requests a cycle. Overlapping requests share the active flight and produce\n   * at most one queued rerun.\n   * @param {string} [reason] - Diagnostic trigger label (never persisted).\n   * @returns {Promise<void>} - Resolves after the current or queued cycle drains.\n   */\n  trigger(reason = \"manual\") {\n    void reason\n    if (!this._active) return Promise.resolve()\n\n    this._rerunRequested = true\n    if (this._startPromise) {\n      return this._startPromise.then(\n        async () => await this._startRequestedRun(),\n        () => undefined\n      )\n    }\n\n    return this._startRequestedRun()\n  }\n\n  /**\n   * Starts requested work only after lifecycle preparation has completed.\n   * @returns {Promise<void>} - Current or newly started coordinator flight.\n   */\n  _startRequestedRun() {\n    if (!this._active) return Promise.resolve()\n    if (this._retryTimer !== null) return this._runPromise || Promise.resolve()\n    if (!this._runPromise) {\n      const generation = this._generation\n\n      this._runPromise = this._drain(generation).finally(() => {\n        this._runPromise = null\n      })\n    }\n\n    return this._runPromise\n  }\n\n  /**\n   * Clears backoff and requests one single-flight user retry.\n   * @returns {Promise<void>} - Resolves after the retry cycle drains.\n   */\n  retry() {\n    if (!this._active) throw new Error(\"Cannot retry a stopped SyncCoordinator\")\n\n    this._clearRetryTimer()\n    this._attempt = 0\n\n    return this.trigger(\"manual-retry\")\n  }\n\n  /**\n   * Resolves one durable conflict through SyncClient, then refreshes status and\n   * replays retry-local intent through the same cycle.\n   * @param {{recordId: string, resolution: \"keep-server\" | \"retry-local\", resourceType: string}} args - Explicit resolution.\n   * @returns {Promise<void>} - Resolves after resolution state is refreshed.\n   */\n  async resolveConflict(args) {\n    if (!this._active) throw new Error(\"Cannot resolve a conflict on a stopped SyncCoordinator\")\n\n    await this.syncClient.resolveConflict(args)\n    this._clearRetryTimer()\n    this._attempt = 0\n    if (args.resolution === \"retry-local\") {\n      await this.syncClient.waitForScheduledReplay()\n    } else {\n      await this.trigger(\"conflict-resolution\")\n    }\n  }\n\n  /**\n   * Drains requested work serially for one lifecycle generation.\n   * @param {number} generation - Owning generation.\n   * @returns {Promise<void>} - Resolves when no immediate rerun remains.\n   */\n  async _drain(generation) {\n    while (this._rerunRequested && this._ownsGeneration(generation)) {\n      this._rerunRequested = false\n      await this._runCycle(generation)\n\n      if (this._rerunRequested) this._clearRetryTimer()\n    }\n  }\n\n  /**\n   * Runs one replay, realtime-subscribe, and pull cycle.\n   * @param {number} generation - Owning generation.\n   * @returns {Promise<void>} - Resolves after this cycle settles.\n   */\n  async _runCycle(generation) {\n    try {\n      const online = await this.syncClient.isOnline()\n\n      this._assertActive(generation)\n      if (!online) {\n        const inspection = await this.syncClient.inspectSyncState()\n\n        this._assertActive(generation)\n        this._publish({...this._status, ...inspection, failure: null, nextRetryAt: null, state: \"offline\"})\n        await this._persistStatus(generation)\n\n        return\n      }\n\n      this._publish({...this._status, nextRetryAt: null, state: \"syncing\"})\n      await this.syncClient.replayPending()\n      this._assertActive(generation)\n      if (this.realtime) {\n        await this.syncClient.subscribeRealtime()\n        this._assertActive(generation)\n      }\n      await this.syncClient.pull()\n      this._assertActive(generation)\n\n      const inspection = await this.syncClient.inspectSyncState()\n\n      this._assertActive(generation)\n      this._publish({\n        ...this._status,\n        ...inspection,\n        failure: null,\n        lastSuccessAt: this._nowIso(),\n        nextRetryAt: null,\n        state: inspectionState(inspection)\n      })\n      await this._persistStatus(generation)\n      this._attempt = 0\n\n      return\n    } catch (error) {\n      if (!this._ownsGeneration(generation) || this.isLifecycleAbort(error) || this.syncClient.isLifecycleAbort(error)) return\n\n      await this._handleFailure(/** @type {Error} */ (error), generation)\n    }\n  }\n\n  /**\n   * Publishes a classified failure and owns its bounded retry timer.\n   * @param {Error} error - Cycle failure.\n   * @param {number} generation - Owning generation.\n   * @returns {Promise<void>} - Resolves after status persistence and scheduling.\n   */\n  async _handleFailure(error, generation) {\n    this._attempt += 1\n    let classified = normalizeErrorClassification(this.classifyError(error))\n    const failedAt = this._nowIso()\n    let failureStatus = failureStatusFor({attempt: this._attempt, classified, failedAt, retryPolicy: this.retryPolicy, status: this._status})\n\n    this._publish(failureStatus.status)\n\n    if (this.statusStore) {\n      try {\n        await this.statusStore.save(this._status)\n        this._assertActive(generation)\n      } catch (persistenceError) {\n        this._assertActive(generation)\n        classified = normalizeErrorClassification(this.classifyError(/** @type {Error} */ (persistenceError)))\n        failureStatus = failureStatusFor({attempt: this._attempt, classified, failedAt, retryPolicy: this.retryPolicy, status: this._status})\n        this._publish(failureStatus.status)\n      }\n    }\n\n    if (failureStatus.delayMs !== null) {\n      this._assertActive(generation)\n      this._retryTimer = this.scheduler.setTimeout(() => {\n        this._retryTimer = null\n        if (!this._ownsGeneration(generation)) return\n\n        void this.trigger(\"automatic-retry\")\n      }, failureStatus.delayMs)\n    }\n\n    this.syncClient.reportError(error)\n  }\n\n  /**\n   * Persists the current safe status for an active generation.\n   * @param {number} generation - Owning generation.\n   * @returns {Promise<void>} - Resolves after persistence.\n   */\n  async _persistStatus(generation) {\n    if (this.statusStore) await this.statusStore.save(this._status)\n    this._assertActive(generation)\n  }\n\n  /**\n   * Coalesces one connectivity change into the coordinator cycle.\n   * @param {{generation: number, online: boolean}} args - Connectivity event.\n   * @returns {void}\n   */\n  _connectivityChanged({generation, online}) {\n    if (!this._ownsGeneration(generation)) return\n\n    this._clearRetryTimer()\n    if (online) this._attempt = 0\n    void this.trigger(online ? \"connectivity-online\" : \"connectivity-offline\")\n  }\n\n  /**\n   * Clears the currently owned retry timer, if present.\n   * @returns {void}\n   */\n  _clearRetryTimer() {\n    if (this._retryTimer === null) return\n\n    this.scheduler.clearTimeout(this._retryTimer)\n    this._retryTimer = null\n  }\n\n  /**\n   * Checks whether a lifecycle generation still owns state updates.\n   * @param {number} generation - Expected generation.\n   * @returns {boolean} - Whether the generation is current and active.\n   */\n  _ownsGeneration(generation) {\n    return this._active && this._generation === generation\n  }\n\n  /**\n   * Fails when work no longer belongs to the active generation.\n   * @param {number} generation - Expected generation.\n   * @returns {void}\n   */\n  _assertActive(generation) {\n    if (this._ownsGeneration(generation)) return\n\n    throw new SyncCoordinatorLifecycleAbortError(\"Sync coordinator work belongs to an inactive generation\")\n  }\n\n  /**\n   * Identifies coordinator-owned cooperative cancellation.\n   * @param {unknown} error - Candidate error.\n   * @returns {boolean} - Whether this coordinator created the abort error.\n   */\n  isLifecycleAbort(error) {\n    return error instanceof SyncCoordinatorLifecycleAbortError\n  }\n\n  /**\n   * Reads and validates the injected clock.\n   * @returns {string} - Valid ISO clock value.\n   */\n  _nowIso() {\n    const value = this.now()\n\n    if (!(value instanceof Date) || Number.isNaN(value.getTime())) throw new Error(\"SyncCoordinator now() must return a valid Date\")\n\n    return value.toISOString()\n  }\n\n  /**\n   * Freezes and publishes a new observable snapshot.\n   * @param {import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus} status - New status.\n   * @returns {void}\n   */\n  _publish(status) {\n    this._status = immutableStatus(status)\n\n    for (const listener of this._listeners) listener(this._status)\n  }\n\n  /**\n   * Returns the current observable snapshot.\n   * @returns {import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus} - Current immutable snapshot.\n   */\n  status() {\n    return this._status\n  }\n\n  /**\n   * Observes status and receives the current snapshot immediately.\n   * @param {(status: import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus) => void} listener - Observer.\n   * @returns {() => void} - Idempotent unsubscribe.\n   */\n  subscribe(listener) {\n    requireFunction(listener, \"status listener\")\n    this._listeners.add(listener)\n    listener(this._status)\n\n    return () => this._listeners.delete(listener)\n  }\n\n  /**\n   * Awaits only the active or queued cycle, not a future backoff timer.\n   * @returns {Promise<void>} - Resolves when current work drains.\n   */\n  async waitForCurrentRun() {\n    while (this._runPromise) await this._runPromise\n  }\n}\n\n/**\n * Builds the default global timer adapter.\n * @returns {import(\"./sync-coordinator-types.js\").SyncCoordinatorScheduler} - Global timer adapter.\n */\nfunction defaultScheduler() {\n  return {\n    clearTimeout: (timer) => globalThis.clearTimeout(/** @type {ReturnType<typeof setTimeout>} */ (timer)),\n    setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs)\n  }\n}\n\n/**\n * Validates and fills retry policy defaults.\n * @param {Record<string, number>} retry - Retry overrides.\n * @returns {{initialDelayMs: number, maxAttempts: number, maxDelayMs: number}} - Complete policy.\n */\nfunction normalizeRetryPolicy(retry) {\n  const policy = {...DEFAULT_RETRY, ...retry}\n\n  for (const [name, value] of Object.entries(policy)) {\n    if (!Number.isInteger(value) || value < 1) throw new Error(`SyncCoordinator retry.${name} must be a positive integer`)\n  }\n  if (policy.maxDelayMs < policy.initialDelayMs) throw new Error(\"SyncCoordinator retry.maxDelayMs must be greater than or equal to initialDelayMs\")\n\n  return policy\n}\n\n/**\n * Classifies unknown errors as permanent without exposing their messages.\n * @param {Error} _error - Unclassified error.\n * @returns {{code: string, retryable: boolean}} - Safe default classification.\n */\nfunction defaultErrorClassification(_error) {\n  return {code: \"sync_failed\", retryable: false}\n}\n\n/**\n * Validates application-provided safe error metadata.\n * @param {ReturnType<typeof defaultErrorClassification> & {message?: string}} classification - Raw classification.\n * @returns {{code: string, message?: string, retryable: boolean}} - Validated classification.\n */\nfunction normalizeErrorClassification(classification) {\n  if (!classification || typeof classification !== \"object\" || Array.isArray(classification)) throw new Error(\"SyncCoordinator classifyError must return an object\")\n  if (typeof classification.code !== \"string\" || classification.code.length === 0) throw new Error(\"SyncCoordinator error classification code must be a non-empty string\")\n  if (typeof classification.retryable !== \"boolean\") throw new Error(\"SyncCoordinator error classification retryable must be boolean\")\n  if (classification.message !== undefined && typeof classification.message !== \"string\") throw new Error(\"SyncCoordinator error classification message must be a string\")\n\n  return classification\n}\n\n/**\n * Builds one failure snapshot and its optional automatic-retry delay.\n * @param {{attempt: number, classified: {code: string, message?: string, retryable: boolean}, failedAt: string, retryPolicy: {initialDelayMs: number, maxAttempts: number, maxDelayMs: number}, status: import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus}} args - Failure state.\n * @returns {{delayMs: number | null, status: import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus}} - Failure snapshot and retry delay.\n */\nfunction failureStatusFor({attempt, classified, failedAt, retryPolicy, status}) {\n  const retryable = classified.retryable && attempt < retryPolicy.maxAttempts\n  const delayMs = retryable ? Math.min(retryPolicy.initialDelayMs * (2 ** (attempt - 1)), retryPolicy.maxDelayMs) : null\n  const failure = {\n    attempt,\n    at: failedAt,\n    code: classified.code,\n    ...(classified.message === undefined ? {} : {message: classified.message}),\n    retryable: classified.retryable\n  }\n  const nextRetryAt = delayMs === null ? null : new Date(new Date(failedAt).getTime() + delayMs).toISOString()\n\n  return {\n    delayMs,\n    status: immutableStatus({...status, failure, nextRetryAt, state: retryable ? \"backoff\" : \"failed\"})\n  }\n}\n\n/**\n * Maps durable queue state to an observable resting state.\n * @param {import(\"./sync-coordinator-types.js\").SyncClientInspection} inspection - Durable inspection.\n * @returns {import(\"./sync-coordinator-types.js\").SyncCoordinatorState} - Resting state.\n */\nfunction inspectionState(inspection) {\n  if (inspection.conflicts.length > 0) return \"conflicted\"\n  if (inspection.rejectedCount > 0) return \"failed\"\n  if (inspection.pendingCount > 0) return \"pending\"\n\n  return \"idle\"\n}\n\n/**\n * Removes stale in-flight timing from a restored status snapshot.\n * @param {import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus} status - Stored status.\n * @returns {import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus} - Restored observable status.\n */\nfunction restoredStatus(status) {\n  if (!COORDINATOR_STATES.has(status.state)) throw new Error(`Unknown persisted SyncCoordinator state: ${String(status.state)}`)\n\n  return {\n    conflicts: status.conflicts,\n    failure: status.failure,\n    lastSuccessAt: status.lastSuccessAt,\n    nextRetryAt: null,\n    pendingCount: status.pendingCount,\n    rejectedCount: status.rejectedCount,\n    state: status.state === \"syncing\" || status.state === \"backoff\" ? inspectionState(status) : status.state\n  }\n}\n\n/**\n * Deep-freezes the status-owned diagnostic collections.\n * @param {import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus} status - Snapshot.\n * @returns {import(\"./sync-coordinator-types.js\").SyncCoordinatorStatus} - Immutable snapshot.\n */\nfunction immutableStatus(status) {\n  const conflicts = status.conflicts.map((conflict) => Object.freeze({...conflict}))\n  const failure = status.failure ? Object.freeze({...status.failure}) : null\n\n  return Object.freeze({...status, conflicts: Object.freeze(conflicts), failure})\n}\n\n/**\n * Validates one required callback.\n * @param {unknown} value - Function candidate.\n * @param {string} label - Contract label.\n * @returns {void} - Validates the function candidate.\n */\nfunction requireFunction(value, label) {\n  if (typeof value !== \"function\") throw new Error(`SyncCoordinator ${label} must be a function`)\n}\n\n/**\n * Validates the SyncClient surface required by the coordinator.\n * @param {import(\"./sync-client.js\").default} client - Client.\n * @returns {void}\n */\nfunction requireCoordinatorClient(client) {\n  if (!client) throw new Error(\"SyncCoordinator requires a SyncClient\")\n\n  requireFunction(client.attachCoordinator, \"syncClient.attachCoordinator\")\n  requireFunction(client.inspectSyncState, \"syncClient.inspectSyncState\")\n  requireFunction(client.isLifecycleAbort, \"syncClient.isLifecycleAbort\")\n  requireFunction(client.isOnline, \"syncClient.isOnline\")\n  requireFunction(client.pull, \"syncClient.pull\")\n  requireFunction(client.reportError, \"syncClient.reportError\")\n  requireFunction(client.replayPending, \"syncClient.replayPending\")\n  requireFunction(client.resolveConflict, \"syncClient.resolveConflict\")\n  requireFunction(client.start, \"syncClient.start\")\n  requireFunction(client.stop, \"syncClient.stop\")\n  requireFunction(client.subscribeRealtime, \"syncClient.subscribeRealtime\")\n  requireFunction(client.waitForScheduledReplay, \"syncClient.waitForScheduledReplay\")\n}\n"]}