velocious 1.0.643 → 1.0.644

package/build/src/sync/assets/cache.js

@@ -0,0 +1,883 @@
+// @ts-check
+import sha256BytesHex from "../../utils/sha256-bytes-hex.js";
+/**
+ * @typedef {{
+ *   byteSize: number,
+ *   contentType: string | null,
+ *   promise: Promise<{error: Error, uri: null} | {error: null, uri: string}>
+ * }} SynchronizedAssetDownloadFlight */
+const CACHE_STATE_VERSION = 1;
+const DEFAULT_RETRY_BASE_DELAY_MS = 1000;
+const DEFAULT_RETRY_MAX_DELAY_MS = 1000 * 60 * 5;
+/**
+ * Core synchronized asset cache. Platform packages own byte and metadata
+ * persistence while this class owns policy, integrity, and lifecycle.
+ */
+export default class SynchronizedAssetCache {
+    /**
+     * Creates a synchronized asset cache.
+     * @param {object} args Options.
+     * @param {string} args.accountId Authenticated account namespace.
+     * @param {import("./types.js").SynchronizedAssetCacheAdapter} args.adapter Platform storage adapter.
+     * @param {(descriptor: import("./types.js").SynchronizedAssetCacheDescriptor) => Promise<Uint8Array>} args.download Authenticated byte downloader.
+     * @param {number} args.maxBytes Maximum evictable cache size.
+     * @param {() => Date} [args.now] Clock.
+     * @param {number} [args.retryBaseDelayMs] Initial retry delay.
+     * @param {number} [args.retryMaxDelayMs] Maximum retry delay.
+     */
+    constructor({ accountId, adapter, download, maxBytes, now = () => new Date(), retryBaseDelayMs = DEFAULT_RETRY_BASE_DELAY_MS, retryMaxDelayMs = DEFAULT_RETRY_MAX_DELAY_MS }) {
+        if (!accountId)
+            throw new Error("Synchronized asset cache requires an account id");
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+            throw new Error("Synchronized asset cache maxBytes must be a non-negative safe integer");
+        if (!Number.isSafeInteger(retryBaseDelayMs) || retryBaseDelayMs < 1)
+            throw new Error("Synchronized asset cache retryBaseDelayMs must be a positive safe integer");
+        if (!Number.isSafeInteger(retryMaxDelayMs) || retryMaxDelayMs < retryBaseDelayMs)
+            throw new Error("Synchronized asset cache retryMaxDelayMs must be at least retryBaseDelayMs");
+        this.accountId = accountId;
+        this.adapter = adapter;
+        this.download = download;
+        this.maxBytes = maxBytes;
+        this.now = now;
+        this.retryBaseDelayMs = retryBaseDelayMs;
+        this.retryMaxDelayMs = retryMaxDelayMs;
+        /** @type {Map<string, number>} */
+        this.activeDigestCounts = new Map();
+        /** @type {Map<string, Promise<void>>} */
+        this.deletionPromises = new Map();
+        /** @type {Set<string>} */
+        this.cleanupRequiredAfterReleaseDigests = new Set();
+        /** @type {Promise<number>} */
+        this.cleanupPromise = Promise.resolve(0);
+        /** @type {Map<string, SynchronizedAssetDownloadFlight>} */
+        this.downloadPromises = new Map();
+        /** @type {import("./types.js").SynchronizedAssetCacheState | null} */
+        this.state = null;
+        /** @type {Promise<import("./types.js").SynchronizedAssetCacheState> | null} */
+        this.statePromise = null;
+        /** @type {Promise<void>} */
+        this.saveStatePromise = Promise.resolve();
+        /** @type {Map<string, Promise<import("./types.js").SynchronizedAssetCacheSynchronizationResult>>} */
+        this.synchronizePromises = new Map();
+    }
+    /**
+     * Reconciles the immutable descriptors for one synchronized scope and
+     * downloads eligible eager assets.
+     * @param {object} args Reconciliation inputs.
+     * @param {import("./types.js").SynchronizedAssetCacheDescriptor[]} args.descriptors Current descriptors in the scope.
+     * @param {boolean} args.online Whether authenticated downloads are available.
+     * @param {string} args.scopeKey Stable synchronized scope key.
+     * @returns {Promise<import("./types.js").SynchronizedAssetCacheSynchronizationResult>} Synchronization result.
+     */
+    async synchronize({ descriptors, online, scopeKey }) {
+        const synchronize = async () => await this.synchronizeScope({ descriptors, online, scopeKey });
+        const previousSynchronizationPromise = this.synchronizePromises.get(scopeKey);
+        const synchronizationPromise = previousSynchronizationPromise
+            ? previousSynchronizationPromise.then(synchronize, synchronize)
+            : synchronize();
+        this.synchronizePromises.set(scopeKey, synchronizationPromise);
+        try {
+            return await synchronizationPromise;
+        }
+        finally {
+            if (this.synchronizePromises.get(scopeKey) === synchronizationPromise) {
+                this.synchronizePromises.delete(scopeKey);
+            }
+        }
+    }
+    /**
+     * Runs one scope synchronization after prior calls for that scope finish.
+     * @param {object} args Reconciliation inputs.
+     * @param {import("./types.js").SynchronizedAssetCacheDescriptor[]} args.descriptors Current descriptors in the scope.
+     * @param {boolean} args.online Whether authenticated downloads are available.
+     * @param {string} args.scopeKey Stable synchronized scope key.
+     * @returns {Promise<import("./types.js").SynchronizedAssetCacheSynchronizationResult>} Synchronization result.
+     */
+    async synchronizeScope({ descriptors, online, scopeKey }) {
+        await this.loadState();
+        /** @type {Map<string, import("./types.js").SynchronizedAssetCacheDescriptor[]>} */
+        const descriptorsByDigest = new Map();
+        /** @type {import("./types.js").SynchronizedAssetCacheFailure[]} */
+        const failures = [];
+        /** @type {Set<string>} */
+        const activeDigests = new Set();
+        for (const descriptor of descriptors) {
+            const digestDescriptors = descriptorsByDigest.get(descriptor.digest) || [];
+            digestDescriptors.push(descriptor);
+            descriptorsByDigest.set(descriptor.digest, digestDescriptors);
+        }
+        try {
+            for (const digest of descriptorsByDigest.keys()) {
+                await this.beginActiveDigest(digest);
+                activeDigests.add(digest);
+            }
+            const entriesById = await this.reconcileDescriptors({ descriptors, scopeKey });
+            await this.deleteUnreferencedDigests();
+            for (const [digest, digestDescriptors] of descriptorsByDigest) {
+                const eagerDescriptors = online ? digestDescriptors.filter((descriptor) => descriptor.fetch === "eager") : [];
+                if (eagerDescriptors.length === 0) {
+                    activeDigests.delete(digest);
+                    await this.finishActiveDigest(digest);
+                    continue;
+                }
+                /** @type {import("./types.js").SynchronizedAssetCacheEntry[]} */
+                const eagerEntries = [];
+                for (const descriptor of eagerDescriptors) {
+                    const entry = entriesById.get(descriptor.id);
+                    if (!entry)
+                        throw new Error(`Missing reconciled synchronized asset descriptor ${descriptor.id}`);
+                    eagerEntries.push(entry);
+                }
+                if (eagerEntries.some((entry) => this.retryEligible(entry))) {
+                    const cacheResult = await this.ensureCachedWhileActive(eagerEntries);
+                    if (cacheResult.error) {
+                        for (const entry of eagerEntries) {
+                            failures.push({ assetId: entry.descriptor.id, error: cacheResult.error });
+                        }
+                    }
+                }
+                activeDigests.delete(digest);
+                await this.finishActiveDigest(digest);
+                await this.cleanup();
+            }
+        }
+        finally {
+            await this.finishActiveDigests([...activeDigests]);
+        }
+        await this.cleanup();
+        return {
+            failures,
+            missingRequiredAssetIds: await this.missingRequiredAssetIds(scopeKey)
+        };
+    }
+    /**
+     * Resolves a cached asset URI, downloading it on demand when allowed.
+     * @param {object} args Resolution inputs.
+     * @param {string} args.assetId Attachment descriptor id.
+     * @param {boolean} args.online Whether authenticated downloads are available.
+     * @returns {Promise<string | null>} Cached asset URI.
+     */
+    async resolve({ assetId, online }) {
+        const state = await this.loadState();
+        const entry = state.assets.find((candidate) => candidate.descriptor.id === assetId);
+        if (!entry)
+            return null;
+        const digest = entry.descriptor.digest;
+        let resolvedUri = null;
+        let shouldCleanup = false;
+        await this.beginActiveDigest(digest);
+        try {
+            const cachedUri = await this.cachedUriWhileActive(entry);
+            if (cachedUri) {
+                entry.lastAccessedAt = this.nowMilliseconds();
+                entry.status = "cached";
+                await this.saveState();
+                resolvedUri = cachedUri;
+            }
+            else if (online && this.retryEligible(entry)) {
+                const cacheResult = await this.ensureCachedWhileActive([entry]);
+                if (cacheResult.error)
+                    throw cacheResult.error;
+                if (cacheResult.uri) {
+                    resolvedUri = cacheResult.uri;
+                    shouldCleanup = true;
+                }
+            }
+        }
+        finally {
+            await this.finishActiveDigest(digest, shouldCleanup ? new Set([digest]) : new Set());
+        }
+        if (shouldCleanup)
+            await this.cleanup(new Set([digest]));
+        const requiresUnprotectedCleanup = shouldCleanup || (entry.descriptor.byteSize > this.maxBytes && !state.assets.some((candidate) => {
+            return candidate.descriptor.digest === digest && candidate.descriptor.retention === "durable";
+        }));
+        if (requiresUnprotectedCleanup)
+            await this.cleanup();
+        if (!resolvedUri)
+            return null;
+        const resolvedEntry = state.assets.find((candidate) => candidate.descriptor.id === assetId && candidate.descriptor.digest === digest);
+        if (!resolvedEntry)
+            return null;
+        return await this.cachedUri(resolvedEntry);
+    }
+    /**
+     * Evicts least-recently-used blobs until the unique cached byte total is
+     * within the configured budget. A blob stays durable when any live
+     * descriptor reference declares durable retention.
+     * @param {Set<string>} [protectedDigests] Digests needed by the active caller.
+     * @returns {Promise<number>} Bytes removed.
+     */
+    async cleanup(protectedDigests = new Set()) {
+        const cleanup = async () => await this.performCleanup(protectedDigests);
+        const cleanupPromise = this.cleanupPromise.then(cleanup, cleanup);
+        this.cleanupPromise = cleanupPromise;
+        return await cleanupPromise;
+    }
+    /**
+     * Performs one serialized eviction pass.
+     * @param {Set<string>} protectedDigests Digests needed by the active caller.
+     * @returns {Promise<number>} Bytes removed.
+     */
+    async performCleanup(protectedDigests) {
+        const state = await this.loadState();
+        /** @type {Map<string, import("./types.js").SynchronizedAssetCacheEntry[]>} */
+        const entriesByDigest = new Map();
+        for (const entry of state.assets) {
+            const digestEntries = entriesByDigest.get(entry.descriptor.digest) || [];
+            digestEntries.push(entry);
+            entriesByDigest.set(entry.descriptor.digest, digestEntries);
+        }
+        /** @type {{byteSize: number, digest: string, lastAccessedAt: number}[]} */
+        const cachedBlobs = [];
+        let cachedBytes = 0;
+        for (const [digest, references] of entriesByDigest) {
+            const uri = await this.adapter.blobUri({ accountId: this.accountId, digest });
+            if (!uri) {
+                for (const entry of references) {
+                    if (entry.status === "cached")
+                        entry.status = "missing";
+                }
+                continue;
+            }
+            const byteSize = references[0].descriptor.byteSize;
+            cachedBytes += byteSize;
+            cachedBlobs.push({
+                byteSize,
+                digest,
+                lastAccessedAt: Math.max(...references.map((entry) => entry.lastAccessedAt))
+            });
+        }
+        let removedBytes = 0;
+        while (cachedBlobs.length > 0) {
+            if (cachedBytes <= this.maxBytes)
+                break;
+            for (const cachedBlob of cachedBlobs) {
+                const currentReferences = state.assets.filter((entry) => entry.descriptor.digest === cachedBlob.digest);
+                if (currentReferences.length > 0) {
+                    cachedBlob.lastAccessedAt = Math.max(...currentReferences.map((entry) => entry.lastAccessedAt));
+                }
+            }
+            cachedBlobs.sort((left, right) => left.lastAccessedAt - right.lastAccessedAt || left.digest.localeCompare(right.digest));
+            const blob = cachedBlobs.shift();
+            if (!blob)
+                throw new Error("Expected a synchronized asset cache eviction candidate");
+            if (protectedDigests.has(blob.digest))
+                continue;
+            let blobWasAlreadyMissing = false;
+            let deletionChecked = false;
+            const deleted = await this.deleteDigestIfInactive(blob.digest, async () => {
+                deletionChecked = true;
+                if (!this.state)
+                    throw new Error("Cannot clean synchronized asset blobs before loading state");
+                const currentUri = await this.adapter.blobUri({ accountId: this.accountId, digest: blob.digest });
+                const currentReferences = this.state.assets.filter((entry) => entry.descriptor.digest === blob.digest);
+                if (!currentUri) {
+                    blobWasAlreadyMissing = true;
+                    for (const entry of currentReferences) {
+                        if (entry.status === "cached")
+                            entry.status = "missing";
+                    }
+                    return false;
+                }
+                if (currentReferences.some((entry) => entry.descriptor.retention === "durable"))
+                    return false;
+                await this.adapter.deleteBlob({ accountId: this.accountId, digest: blob.digest });
+                for (const entry of currentReferences) {
+                    entry.attempts = 0;
+                    entry.nextRetryAt = null;
+                    entry.status = "missing";
+                }
+                return true;
+            });
+            if (!deletionChecked)
+                this.cleanupRequiredAfterReleaseDigests.add(blob.digest);
+            if (blobWasAlreadyMissing)
+                cachedBytes -= blob.byteSize;
+            if (!deleted)
+                continue;
+            cachedBytes -= blob.byteSize;
+            removedBytes += blob.byteSize;
+        }
+        await this.saveState();
+        return removedBytes;
+    }
+    /**
+     * Loads cache state once for this cache instance.
+     * @returns {Promise<import("./types.js").SynchronizedAssetCacheState>} Loaded state.
+     */
+    async loadState() {
+        if (this.state)
+            return this.state;
+        if (this.statePromise)
+            return await this.statePromise;
+        this.statePromise = this.loadStateFromAdapter();
+        try {
+            this.state = await this.statePromise;
+            return this.state;
+        }
+        finally {
+            this.statePromise = null;
+        }
+    }
+    /**
+     * Loads and recovers persisted cache state.
+     * @returns {Promise<import("./types.js").SynchronizedAssetCacheState>} Loaded state.
+     */
+    async loadStateFromAdapter() {
+        const loadedState = await this.adapter.loadState({ accountId: this.accountId });
+        if (!loadedState)
+            return { assets: [], pendingDeletionDigests: [], version: CACHE_STATE_VERSION };
+        if (loadedState.version !== CACHE_STATE_VERSION) {
+            throw new Error(`Unsupported synchronized asset cache state version: ${loadedState.version}`);
+        }
+        let recoveredInterruptedDownload = false;
+        for (const entry of loadedState.assets) {
+            if (entry.status !== "downloading")
+                continue;
+            entry.attempts += 1;
+            entry.nextRetryAt = this.nowMilliseconds();
+            entry.status = "failed";
+            recoveredInterruptedDownload = true;
+        }
+        if (recoveredInterruptedDownload) {
+            await this.adapter.saveState({ accountId: this.accountId, state: loadedState });
+        }
+        return loadedState;
+    }
+    /**
+     * Persists the current cache state.
+     * @returns {Promise<void>} Resolves after state persistence.
+     */
+    async saveState() {
+        if (!this.state)
+            throw new Error("Cannot save synchronized asset cache before loading state");
+        const state = this.copyState(this.state);
+        const persist = async () => {
+            await this.adapter.saveState({ accountId: this.accountId, state });
+        };
+        await this.serializeStatePersistence(persist);
+    }
+    /**
+     * Persists a detached reconciliation before exposing it through shared state.
+     * @param {object} args Reconciliation inputs.
+     * @param {import("./types.js").SynchronizedAssetCacheDescriptor[]} args.descriptors Current descriptors in the scope.
+     * @param {string} args.scopeKey Stable synchronized scope key.
+     * @returns {Promise<Map<string, import("./types.js").SynchronizedAssetCacheEntry>>} Reconciled live entries by id.
+     */
+    async reconcileDescriptors({ descriptors, scopeKey }) {
+        /** @type {Map<string, import("./types.js").SynchronizedAssetCacheEntry> | null} */
+        let entriesById = null;
+        const persist = async () => {
+            if (!this.state)
+                throw new Error("Cannot reconcile synchronized asset cache before loading state");
+            const candidateState = this.copyState(this.state);
+            const newEntryLastAccessedAt = this.nowMilliseconds();
+            this.applyDescriptorReconciliation({ descriptors, newEntryLastAccessedAt, scopeKey, state: candidateState });
+            await this.adapter.saveState({ accountId: this.accountId, state: candidateState });
+            entriesById = this.applyDescriptorReconciliation({ descriptors, newEntryLastAccessedAt, scopeKey, state: this.state });
+        };
+        await this.serializeStatePersistence(persist);
+        if (!entriesById)
+            throw new Error("Synchronized asset descriptor reconciliation completed without live entries");
+        return entriesById;
+    }
+    /**
+     * Applies one scope's descriptor set to cache state.
+     * @param {object} args Reconciliation inputs.
+     * @param {import("./types.js").SynchronizedAssetCacheDescriptor[]} args.descriptors Current descriptors in the scope.
+     * @param {number} args.newEntryLastAccessedAt Initial LRU timestamp for new entries.
+     * @param {string} args.scopeKey Stable synchronized scope key.
+     * @param {import("./types.js").SynchronizedAssetCacheState} args.state State to reconcile.
+     * @returns {Map<string, import("./types.js").SynchronizedAssetCacheEntry>} Live entries by id.
+     */
+    applyDescriptorReconciliation({ descriptors, newEntryLastAccessedAt, scopeKey, state }) {
+        const incomingIds = new Set(descriptors.map((asset) => asset.id));
+        const entriesById = new Map(state.assets.map((entry) => [entry.descriptor.id, entry]));
+        const descriptorsById = new Map(state.assets.map((entry) => [entry.descriptor.id, entry.descriptor]));
+        /** @type {Map<string, import("./types.js").SynchronizedAssetCacheDescriptor>} */
+        const removedDescriptorsByDigest = new Map();
+        for (const asset of descriptors) {
+            const knownDescriptor = descriptorsById.get(asset.id);
+            const downloadFlight = this.downloadPromises.get(asset.digest);
+            if (knownDescriptor && knownDescriptor.digest !== asset.digest) {
+                throw new Error(`Synchronized asset descriptor ${asset.id} changed its immutable digest`);
+            }
+            if (knownDescriptor && knownDescriptor.byteSize !== asset.byteSize) {
+                throw new Error(`Synchronized asset descriptor ${asset.id} changed its immutable byte size`);
+            }
+            if (knownDescriptor && knownDescriptor.contentType !== asset.contentType) {
+                throw new Error(`Synchronized asset descriptor ${asset.id} changed its immutable content type`);
+            }
+            if (downloadFlight && downloadFlight.byteSize !== asset.byteSize) {
+                throw new Error(`Synchronized asset digest ${asset.digest} has inconsistent byte sizes`);
+            }
+            if (downloadFlight && downloadFlight.contentType !== asset.contentType) {
+                throw new Error(`Synchronized asset digest ${asset.digest} has inconsistent content types`);
+            }
+            descriptorsById.set(asset.id, asset);
+        }
+        for (const entry of state.assets) {
+            if (!entry.scopeKeys.includes(scopeKey) || incomingIds.has(entry.descriptor.id))
+                continue;
+            entry.scopeKeys = entry.scopeKeys.filter((candidate) => candidate !== scopeKey);
+            if (entry.scopeKeys.length === 0)
+                removedDescriptorsByDigest.set(entry.descriptor.digest, entry.descriptor);
+        }
+        state.assets = state.assets.filter((entry) => entry.scopeKeys.length > 0);
+        for (const asset of descriptors) {
+            const existing = entriesById.get(asset.id);
+            if (existing && state.assets.includes(existing)) {
+                existing.descriptor = asset;
+                if (!existing.scopeKeys.includes(scopeKey))
+                    existing.scopeKeys.push(scopeKey);
+            }
+            else {
+                const newEntry = {
+                    attempts: 0,
+                    descriptor: asset,
+                    lastAccessedAt: newEntryLastAccessedAt,
+                    nextRetryAt: null,
+                    scopeKeys: [scopeKey],
+                    status: /** @type {const} */ ("missing")
+                };
+                state.assets.push(newEntry);
+                entriesById.set(asset.id, newEntry);
+            }
+        }
+        /** @type {Map<string, number>} */
+        const byteSizesByDigest = new Map();
+        /** @type {Map<string, string | null>} */
+        const contentTypesByDigest = new Map();
+        for (const entry of state.assets) {
+            const knownByteSize = byteSizesByDigest.get(entry.descriptor.digest);
+            const knownContentType = contentTypesByDigest.get(entry.descriptor.digest);
+            if (knownByteSize !== undefined && knownByteSize !== entry.descriptor.byteSize) {
+                throw new Error(`Synchronized asset digest ${entry.descriptor.digest} has inconsistent byte sizes`);
+            }
+            if (knownContentType !== undefined && knownContentType !== entry.descriptor.contentType) {
+                throw new Error(`Synchronized asset digest ${entry.descriptor.digest} has inconsistent content types`);
+            }
+            byteSizesByDigest.set(entry.descriptor.digest, entry.descriptor.byteSize);
+            contentTypesByDigest.set(entry.descriptor.digest, entry.descriptor.contentType);
+        }
+        for (const [digest, removedDescriptor] of removedDescriptorsByDigest) {
+            const retainedEntry = state.assets.find((entry) => entry.descriptor.digest === digest);
+            if (retainedEntry && retainedEntry.descriptor.byteSize === removedDescriptor.byteSize && retainedEntry.descriptor.contentType === removedDescriptor.contentType)
+                continue;
+            if (!state.pendingDeletionDigests.includes(digest))
+                state.pendingDeletionDigests.push(digest);
+        }
+        return entriesById;
+    }
+    /**
+     * Copies metadata into a detached persistence candidate.
+     * @param {import("./types.js").SynchronizedAssetCacheState} state State to copy.
+     * @returns {import("./types.js").SynchronizedAssetCacheState} Detached state.
+     */
+    copyState(state) {
+        return {
+            assets: state.assets.map((entry) => ({
+                ...entry,
+                descriptor: { ...entry.descriptor },
+                scopeKeys: [...entry.scopeKeys]
+            })),
+            pendingDeletionDigests: [...state.pendingDeletionDigests],
+            version: state.version
+        };
+    }
+    /**
+     * Serializes one metadata persistence operation after prior failures or successes.
+     * @param {() => Promise<void>} persist Persistence operation.
+     * @returns {Promise<void>} Resolves after persistence.
+     */
+    async serializeStatePersistence(persist) {
+        this.saveStatePromise = this.saveStatePromise.then(persist, persist);
+        await this.saveStatePromise;
+    }
+    /**
+     * Ensures one descriptor has verified local bytes.
+     * @param {import("./types.js").SynchronizedAssetCacheEntry} entry Descriptor state.
+     * @returns {Promise<{error: Error | null, uri: string | null}>} Cache result.
+     */
+    async ensureCached(entry) {
+        const digest = entry.descriptor.digest;
+        await this.beginActiveDigest(digest);
+        try {
+            return await this.ensureCachedWhileActive([entry]);
+        }
+        finally {
+            await this.finishActiveDigest(digest);
+        }
+    }
+    /**
+     * Resolves or downloads descriptors sharing one protected digest.
+     * @param {import("./types.js").SynchronizedAssetCacheEntry[]} entries Descriptor states.
+     * @returns {Promise<{error: Error | null, uri: string | null}>} Cache result.
+     */
+    async ensureCachedWhileActive(entries) {
+        const entry = entries[0];
+        if (!entry)
+            throw new Error("Cannot cache a synchronized asset digest without descriptor entries");
+        const existingUri = await this.cachedUriWhileActive(entry);
+        if (existingUri) {
+            await this.recordCachedEntries(entries);
+            return { error: null, uri: existingUri };
+        }
+        const digest = entry.descriptor.digest;
+        let downloadFlight = this.downloadPromises.get(digest);
+        let ownsDownloadPromise = false;
+        if (downloadFlight) {
+            for (const digestEntry of entries) {
+                if (downloadFlight.byteSize !== digestEntry.descriptor.byteSize) {
+                    throw new Error(`Synchronized asset digest ${digest} has inconsistent byte sizes`);
+                }
+                if (downloadFlight.contentType !== digestEntry.descriptor.contentType) {
+                    throw new Error(`Synchronized asset digest ${digest} has inconsistent content types`);
+                }
+            }
+        }
+        for (const digestEntry of entries)
+            digestEntry.status = "downloading";
+        if (!downloadFlight) {
+            downloadFlight = {
+                byteSize: entry.descriptor.byteSize,
+                contentType: entry.descriptor.contentType,
+                promise: this.downloadAfterPersistingState(entry.descriptor)
+            };
+            this.downloadPromises.set(digest, downloadFlight);
+            ownsDownloadPromise = true;
+        }
+        else {
+            await this.saveState();
+        }
+        try {
+            const cacheResult = await downloadFlight.promise;
+            if (cacheResult.error) {
+                if (entry.status === "downloading")
+                    await this.recordDownloadFailure(digest);
+                return cacheResult;
+            }
+            await this.recordCachedEntries(entries);
+            return cacheResult;
+        }
+        finally {
+            if (ownsDownloadPromise && this.downloadPromises.get(digest) === downloadFlight) {
+                this.downloadPromises.delete(digest);
+            }
+        }
+    }
+    /**
+     * Records one cached digest result for every participating descriptor.
+     * @param {import("./types.js").SynchronizedAssetCacheEntry[]} entries Descriptor states.
+     * @returns {Promise<void>} Resolves after persistence.
+     */
+    async recordCachedEntries(entries) {
+        if (!this.state)
+            throw new Error("Cannot record synchronized asset cache results before loading state");
+        const state = this.state;
+        const lastAccessedAt = this.nowMilliseconds();
+        for (const entry of entries) {
+            entry.attempts = 0;
+            entry.lastAccessedAt = lastAccessedAt;
+            entry.nextRetryAt = null;
+            entry.status = "cached";
+        }
+        const verifiedDigests = new Set(entries.map((entry) => entry.descriptor.digest));
+        state.pendingDeletionDigests = state.pendingDeletionDigests.filter((digest) => {
+            return !verifiedDigests.has(digest) || !state.assets.some((entry) => entry.descriptor.digest === digest);
+        });
+        await this.saveState();
+    }
+    /**
+     * Persists download intent, then downloads one digest and records a shared failure once.
+     * @param {import("./types.js").SynchronizedAssetCacheDescriptor} descriptor Asset descriptor.
+     * @returns {Promise<{error: Error, uri: null} | {error: null, uri: string}>} Shared cache result.
+     */
+    async downloadAfterPersistingState(descriptor) {
+        await this.saveState();
+        try {
+            return { error: null, uri: await this.downloadVerified(descriptor) };
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            await this.recordDownloadFailure(descriptor.digest);
+            return { error: failure, uri: null };
+        }
+    }
+    /**
+     * Advances retry metadata for every live descriptor sharing one failed digest.
+     * @param {string} digest Content digest.
+     * @returns {Promise<void>} Resolves after persistence.
+     */
+    async recordDownloadFailure(digest) {
+        if (!this.state)
+            throw new Error("Cannot record synchronized asset download failure before loading state");
+        const failedAt = this.nowMilliseconds();
+        for (const entry of this.state.assets) {
+            if (entry.descriptor.digest !== digest)
+                continue;
+            if (entry.status !== "downloading")
+                continue;
+            entry.attempts += 1;
+            entry.nextRetryAt = failedAt + this.retryDelay(entry.attempts);
+            entry.status = "failed";
+        }
+        await this.saveState();
+    }
+    /**
+     * Downloads, verifies, and atomically persists one content digest.
+     * @param {import("./types.js").SynchronizedAssetCacheDescriptor} descriptor Asset descriptor.
+     * @returns {Promise<string>} Adapter URI.
+     */
+    async downloadVerified(descriptor) {
+        const downloadedBytes = await this.download(descriptor);
+        if (!(downloadedBytes instanceof Uint8Array)) {
+            throw new Error(`Synchronized asset ${descriptor.id} download did not return Uint8Array bytes`);
+        }
+        if (downloadedBytes.byteLength !== descriptor.byteSize) {
+            throw new Error(`Synchronized asset ${descriptor.id} byte size did not match its descriptor`);
+        }
+        const digest = `sha256-${sha256BytesHex(downloadedBytes)}`;
+        if (digest !== descriptor.digest) {
+            throw new Error(`Synchronized asset ${descriptor.id} digest did not match its descriptor`);
+        }
+        const uri = await this.adapter.writeBlob({
+            accountId: this.accountId,
+            bytes: downloadedBytes,
+            contentType: descriptor.contentType,
+            digest
+        });
+        if (!uri)
+            throw new Error(`Synchronized asset adapter returned no URI for ${descriptor.id}`);
+        return uri;
+    }
+    /**
+     * Resolves an existing local URI after waiting for deletion work.
+     * @param {import("./types.js").SynchronizedAssetCacheEntry} entry Descriptor state.
+     * @returns {Promise<string | null>} Existing URI.
+     */
+    async cachedUri(entry) {
+        const digest = entry.descriptor.digest;
+        while (true) {
+            await this.beginActiveDigest(digest);
+            let revalidationRequired;
+            let uri;
+            try {
+                uri = await this.cachedUriWhileActive(entry);
+            }
+            finally {
+                revalidationRequired = await this.finishActiveDigest(digest);
+            }
+            if (!this.state)
+                throw new Error("Cannot revalidate synchronized asset cache URI before loading state");
+            if (!this.state.assets.some((candidate) => {
+                return candidate.descriptor.id === entry.descriptor.id && candidate.descriptor.digest === digest;
+            }))
+                return null;
+            if (!revalidationRequired)
+                return uri;
+        }
+    }
+    /**
+     * Resolves an existing local URI while its digest is protected.
+     * @param {import("./types.js").SynchronizedAssetCacheEntry} entry Descriptor state.
+     * @returns {Promise<string | null>} Existing URI.
+     */
+    async cachedUriWhileActive(entry) {
+        if (!this.state)
+            throw new Error("Cannot resolve synchronized asset cache URI before loading state");
+        if (this.state.pendingDeletionDigests.includes(entry.descriptor.digest)) {
+            if (entry.status === "cached")
+                entry.status = "missing";
+            return null;
+        }
+        const uri = await this.adapter.blobUri({
+            accountId: this.accountId,
+            digest: entry.descriptor.digest
+        });
+        if (!uri && entry.status === "cached")
+            entry.status = "missing";
+        return uri;
+    }
+    /**
+     * Waits for deletion and protects a digest for one active cache operation.
+     * @param {string} digest Content digest.
+     * @returns {Promise<void>} Resolves after protection is registered.
+     */
+    async beginActiveDigest(digest) {
+        let deletionPromise = this.deletionPromises.get(digest);
+        while (deletionPromise) {
+            await deletionPromise;
+            deletionPromise = this.deletionPromises.get(digest);
+        }
+        const activeCount = this.activeDigestCounts.get(digest) ?? 0;
+        this.activeDigestCounts.set(digest, activeCount + 1);
+    }
+    /**
+     * Releases one cache operation and processes deferred deletion after the last.
+     * @param {string} digest Content digest.
+     * @param {Set<string>} [protectedCleanupDigests] Digests needed by the resolving caller.
+     * @returns {Promise<boolean>} Whether finalization requires URI revalidation.
+     */
+    async finishActiveDigest(digest, protectedCleanupDigests = new Set()) {
+        const activeCount = this.activeDigestCounts.get(digest);
+        if (activeCount === undefined) {
+            throw new Error(`Missing active synchronized asset digest count for ${digest}`);
+        }
+        if (activeCount > 1) {
+            this.activeDigestCounts.set(digest, activeCount - 1);
+            return false;
+        }
+        this.activeDigestCounts.delete(digest);
+        const pendingDigestDeleted = await this.deletePendingDigestIfUnreferenced(digest);
+        const deferredCleanupRequired = this.cleanupRequiredAfterReleaseDigests.delete(digest);
+        if (deferredCleanupRequired)
+            await this.cleanup(protectedCleanupDigests);
+        return pendingDigestDeleted || deferredCleanupRequired;
+    }
+    /**
+     * Releases every acquired digest before propagating finalization failures.
+     * @param {string[]} digests Content digests.
+     * @returns {Promise<void>} Resolves after every digest is released.
+     */
+    async finishActiveDigests(digests) {
+        /** @type {Error[]} */
+        const failures = [];
+        for (const digest of digests) {
+            try {
+                await this.finishActiveDigest(digest);
+            }
+            catch (error) {
+                failures.push(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1) {
+            throw new AggregateError(failures, "Multiple synchronized asset digest finalizers failed", { cause: failures[0] });
+        }
+    }
+    /**
+     * Deletes blobs that lost their final descriptor reference.
+     * @returns {Promise<void>} Resolves after deletion.
+     */
+    async deleteUnreferencedDigests() {
+        if (!this.state)
+            throw new Error("Cannot delete synchronized asset blobs before loading state");
+        for (const digest of [...this.state.pendingDeletionDigests]) {
+            await this.deletePendingDigestIfUnreferenced(digest);
+        }
+    }
+    /**
+     * Deletes one persisted pending digest when no descriptor or active operation owns it.
+     * @param {string} digest Content digest.
+     * @returns {Promise<boolean>} Whether the blob was deleted.
+     */
+    async deletePendingDigestIfUnreferenced(digest) {
+        if (!this.state)
+            throw new Error("Cannot delete synchronized asset blobs before loading state");
+        if (!this.state.pendingDeletionDigests.includes(digest))
+            return false;
+        return await this.deleteDigestIfInactive(digest, async () => {
+            if (!this.state)
+                throw new Error("Cannot delete synchronized asset blobs before loading state");
+            if (!this.state.pendingDeletionDigests.includes(digest))
+                return false;
+            if (this.state.assets.some((entry) => entry.descriptor.digest === digest))
+                return false;
+            await this.adapter.deleteBlob({ accountId: this.accountId, digest });
+            const pendingDeletionDigests = this.state.pendingDeletionDigests;
+            this.state.pendingDeletionDigests = pendingDeletionDigests.filter((candidate) => candidate !== digest);
+            try {
+                await this.saveState();
+            }
+            catch (error) {
+                if (!this.state.pendingDeletionDigests.includes(digest))
+                    this.state.pendingDeletionDigests.push(digest);
+                throw error;
+            }
+            return true;
+        });
+    }
+    /**
+     * Runs one deletion only after earlier deletion work and when no cache operation owns the digest.
+     * @param {string} digest Content digest.
+     * @param {() => Promise<boolean>} callback Protected deletion callback.
+     * @returns {Promise<boolean>} Whether the callback deleted the blob.
+     */
+    async deleteDigestIfInactive(digest, callback) {
+        let activeDeletionPromise = this.deletionPromises.get(digest);
+        while (activeDeletionPromise) {
+            await activeDeletionPromise;
+            activeDeletionPromise = this.deletionPromises.get(digest);
+        }
+        if (this.activeDigestCounts.has(digest))
+            return false;
+        /**
+         * Releases callers waiting for deletion completion.
+         * @type {() => void}
+         */
+        let releaseDeletion = () => { };
+        /**
+         * Blocks new digest activity until deletion completes.
+         * @type {Promise<void>}
+         */
+        const deletionPromise = new Promise((resolve) => {
+            releaseDeletion = () => resolve(undefined);
+        });
+        this.deletionPromises.set(digest, deletionPromise);
+        try {
+            return await callback();
+        }
+        finally {
+            if (this.deletionPromises.get(digest) === deletionPromise)
+                this.deletionPromises.delete(digest);
+            releaseDeletion();
+        }
+    }
+    /**
+     * Finds required assets without locally cached bytes.
+     * @param {string} scopeKey Synchronized scope to inspect.
+     * @returns {Promise<string[]>} Missing required descriptor ids.
+     */
+    async missingRequiredAssetIds(scopeKey) {
+        const state = await this.loadState();
+        /** @type {string[]} */
+        const missingAssetIds = [];
+        for (const entry of state.assets) {
+            if (!entry.scopeKeys.includes(scopeKey))
+                continue;
+            if (entry.descriptor.offlineRequirement !== "required")
+                continue;
+            if (await this.cachedUri(entry))
+                continue;
+            missingAssetIds.push(entry.descriptor.id);
+        }
+        return missingAssetIds;
+    }
+    /**
+     * Checks whether a failed or missing entry may be downloaded now.
+     * @param {import("./types.js").SynchronizedAssetCacheEntry} entry Descriptor state.
+     * @returns {boolean} Whether the retry deadline has passed.
+     */
+    retryEligible(entry) {
+        return entry.status !== "failed" || entry.nextRetryAt === null || entry.nextRetryAt <= this.nowMilliseconds();
+    }
+    /**
+     * Calculates bounded exponential retry delay.
+     * @param {number} attempts Consecutive failures.
+     * @returns {number} Retry delay.
+     */
+    retryDelay(attempts) {
+        return Math.min(this.retryMaxDelayMs, this.retryBaseDelayMs * (2 ** Math.max(0, attempts - 1)));
+    }
+    /**
+     * Reads the injectable wall clock.
+     * @returns {number} Current epoch milliseconds.
+     */
+    nowMilliseconds() {
+        return this.now().getTime();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../../src/sync/assets/cache.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport sha256BytesHex from \"../../utils/sha256-bytes-hex.js\"\n\n/**\n * @typedef {{\n *   byteSize: number,\n *   contentType: string | null,\n *   promise: Promise<{error: Error, uri: null} | {error: null, uri: string}>\n * }} SynchronizedAssetDownloadFlight */\n\nconst CACHE_STATE_VERSION = 1\nconst DEFAULT_RETRY_BASE_DELAY_MS = 1000\nconst DEFAULT_RETRY_MAX_DELAY_MS = 1000 * 60 * 5\n\n/**\n * Core synchronized asset cache. Platform packages own byte and metadata\n * persistence while this class owns policy, integrity, and lifecycle.\n */\nexport default class SynchronizedAssetCache {\n  /**\n   * Creates a synchronized asset cache.\n   * @param {object} args Options.\n   * @param {string} args.accountId Authenticated account namespace.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheAdapter} args.adapter Platform storage adapter.\n   * @param {(descriptor: import(\"./types.js\").SynchronizedAssetCacheDescriptor) => Promise<Uint8Array>} args.download Authenticated byte downloader.\n   * @param {number} args.maxBytes Maximum evictable cache size.\n   * @param {() => Date} [args.now] Clock.\n   * @param {number} [args.retryBaseDelayMs] Initial retry delay.\n   * @param {number} [args.retryMaxDelayMs] Maximum retry delay.\n   */\n  constructor({accountId, adapter, download, maxBytes, now = () => new Date(), retryBaseDelayMs = DEFAULT_RETRY_BASE_DELAY_MS, retryMaxDelayMs = DEFAULT_RETRY_MAX_DELAY_MS}) {\n    if (!accountId) throw new Error(\"Synchronized asset cache requires an account id\")\n    if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) throw new Error(\"Synchronized asset cache maxBytes must be a non-negative safe integer\")\n    if (!Number.isSafeInteger(retryBaseDelayMs) || retryBaseDelayMs < 1) throw new Error(\"Synchronized asset cache retryBaseDelayMs must be a positive safe integer\")\n    if (!Number.isSafeInteger(retryMaxDelayMs) || retryMaxDelayMs < retryBaseDelayMs) throw new Error(\"Synchronized asset cache retryMaxDelayMs must be at least retryBaseDelayMs\")\n\n    this.accountId = accountId\n    this.adapter = adapter\n    this.download = download\n    this.maxBytes = maxBytes\n    this.now = now\n    this.retryBaseDelayMs = retryBaseDelayMs\n    this.retryMaxDelayMs = retryMaxDelayMs\n    /** @type {Map<string, number>} */\n    this.activeDigestCounts = new Map()\n    /** @type {Map<string, Promise<void>>} */\n    this.deletionPromises = new Map()\n    /** @type {Set<string>} */\n    this.cleanupRequiredAfterReleaseDigests = new Set()\n    /** @type {Promise<number>} */\n    this.cleanupPromise = Promise.resolve(0)\n    /** @type {Map<string, SynchronizedAssetDownloadFlight>} */\n    this.downloadPromises = new Map()\n    /** @type {import(\"./types.js\").SynchronizedAssetCacheState | null} */\n    this.state = null\n    /** @type {Promise<import(\"./types.js\").SynchronizedAssetCacheState> | null} */\n    this.statePromise = null\n    /** @type {Promise<void>} */\n    this.saveStatePromise = Promise.resolve()\n    /** @type {Map<string, Promise<import(\"./types.js\").SynchronizedAssetCacheSynchronizationResult>>} */\n    this.synchronizePromises = new Map()\n  }\n\n  /**\n   * Reconciles the immutable descriptors for one synchronized scope and\n   * downloads eligible eager assets.\n   * @param {object} args Reconciliation inputs.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheDescriptor[]} args.descriptors Current descriptors in the scope.\n   * @param {boolean} args.online Whether authenticated downloads are available.\n   * @param {string} args.scopeKey Stable synchronized scope key.\n   * @returns {Promise<import(\"./types.js\").SynchronizedAssetCacheSynchronizationResult>} Synchronization result.\n   */\n  async synchronize({descriptors, online, scopeKey}) {\n    const synchronize = async () => await this.synchronizeScope({descriptors, online, scopeKey})\n    const previousSynchronizationPromise = this.synchronizePromises.get(scopeKey)\n    const synchronizationPromise = previousSynchronizationPromise\n      ? previousSynchronizationPromise.then(synchronize, synchronize)\n      : synchronize()\n\n    this.synchronizePromises.set(scopeKey, synchronizationPromise)\n\n    try {\n      return await synchronizationPromise\n    } finally {\n      if (this.synchronizePromises.get(scopeKey) === synchronizationPromise) {\n        this.synchronizePromises.delete(scopeKey)\n      }\n    }\n  }\n\n  /**\n   * Runs one scope synchronization after prior calls for that scope finish.\n   * @param {object} args Reconciliation inputs.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheDescriptor[]} args.descriptors Current descriptors in the scope.\n   * @param {boolean} args.online Whether authenticated downloads are available.\n   * @param {string} args.scopeKey Stable synchronized scope key.\n   * @returns {Promise<import(\"./types.js\").SynchronizedAssetCacheSynchronizationResult>} Synchronization result.\n   */\n  async synchronizeScope({descriptors, online, scopeKey}) {\n    await this.loadState()\n    /** @type {Map<string, import(\"./types.js\").SynchronizedAssetCacheDescriptor[]>} */\n    const descriptorsByDigest = new Map()\n    /** @type {import(\"./types.js\").SynchronizedAssetCacheFailure[]} */\n    const failures = []\n    /** @type {Set<string>} */\n    const activeDigests = new Set()\n\n    for (const descriptor of descriptors) {\n      const digestDescriptors = descriptorsByDigest.get(descriptor.digest) || []\n\n      digestDescriptors.push(descriptor)\n      descriptorsByDigest.set(descriptor.digest, digestDescriptors)\n    }\n\n    try {\n      for (const digest of descriptorsByDigest.keys()) {\n        await this.beginActiveDigest(digest)\n        activeDigests.add(digest)\n      }\n\n      const entriesById = await this.reconcileDescriptors({descriptors, scopeKey})\n\n      await this.deleteUnreferencedDigests()\n\n      for (const [digest, digestDescriptors] of descriptorsByDigest) {\n        const eagerDescriptors = online ? digestDescriptors.filter((descriptor) => descriptor.fetch === \"eager\") : []\n\n        if (eagerDescriptors.length === 0) {\n          activeDigests.delete(digest)\n          await this.finishActiveDigest(digest)\n          continue\n        }\n\n        /** @type {import(\"./types.js\").SynchronizedAssetCacheEntry[]} */\n        const eagerEntries = []\n\n        for (const descriptor of eagerDescriptors) {\n          const entry = entriesById.get(descriptor.id)\n\n          if (!entry) throw new Error(`Missing reconciled synchronized asset descriptor ${descriptor.id}`)\n\n          eagerEntries.push(entry)\n        }\n\n        if (eagerEntries.some((entry) => this.retryEligible(entry))) {\n          const cacheResult = await this.ensureCachedWhileActive(eagerEntries)\n\n          if (cacheResult.error) {\n            for (const entry of eagerEntries) {\n              failures.push({assetId: entry.descriptor.id, error: cacheResult.error})\n            }\n          }\n        }\n\n        activeDigests.delete(digest)\n        await this.finishActiveDigest(digest)\n        await this.cleanup()\n      }\n    } finally {\n      await this.finishActiveDigests([...activeDigests])\n    }\n\n    await this.cleanup()\n\n    return {\n      failures,\n      missingRequiredAssetIds: await this.missingRequiredAssetIds(scopeKey)\n    }\n  }\n\n  /**\n   * Resolves a cached asset URI, downloading it on demand when allowed.\n   * @param {object} args Resolution inputs.\n   * @param {string} args.assetId Attachment descriptor id.\n   * @param {boolean} args.online Whether authenticated downloads are available.\n   * @returns {Promise<string | null>} Cached asset URI.\n   */\n  async resolve({assetId, online}) {\n    const state = await this.loadState()\n    const entry = state.assets.find((candidate) => candidate.descriptor.id === assetId)\n\n    if (!entry) return null\n\n    const digest = entry.descriptor.digest\n    let resolvedUri = null\n    let shouldCleanup = false\n\n    await this.beginActiveDigest(digest)\n\n    try {\n      const cachedUri = await this.cachedUriWhileActive(entry)\n\n      if (cachedUri) {\n        entry.lastAccessedAt = this.nowMilliseconds()\n        entry.status = \"cached\"\n        await this.saveState()\n\n        resolvedUri = cachedUri\n      } else if (online && this.retryEligible(entry)) {\n        const cacheResult = await this.ensureCachedWhileActive([entry])\n\n        if (cacheResult.error) throw cacheResult.error\n\n        if (cacheResult.uri) {\n          resolvedUri = cacheResult.uri\n          shouldCleanup = true\n        }\n      }\n    } finally {\n      await this.finishActiveDigest(digest, shouldCleanup ? new Set([digest]) : new Set())\n    }\n\n    if (shouldCleanup) await this.cleanup(new Set([digest]))\n    const requiresUnprotectedCleanup = shouldCleanup || (entry.descriptor.byteSize > this.maxBytes && !state.assets.some((candidate) => {\n      return candidate.descriptor.digest === digest && candidate.descriptor.retention === \"durable\"\n    }))\n\n    if (requiresUnprotectedCleanup) await this.cleanup()\n    if (!resolvedUri) return null\n    const resolvedEntry = state.assets.find((candidate) => candidate.descriptor.id === assetId && candidate.descriptor.digest === digest)\n\n    if (!resolvedEntry) return null\n\n    return await this.cachedUri(resolvedEntry)\n  }\n\n  /**\n   * Evicts least-recently-used blobs until the unique cached byte total is\n   * within the configured budget. A blob stays durable when any live\n   * descriptor reference declares durable retention.\n   * @param {Set<string>} [protectedDigests] Digests needed by the active caller.\n   * @returns {Promise<number>} Bytes removed.\n   */\n  async cleanup(protectedDigests = new Set()) {\n    const cleanup = async () => await this.performCleanup(protectedDigests)\n    const cleanupPromise = this.cleanupPromise.then(cleanup, cleanup)\n\n    this.cleanupPromise = cleanupPromise\n\n    return await cleanupPromise\n  }\n\n  /**\n   * Performs one serialized eviction pass.\n   * @param {Set<string>} protectedDigests Digests needed by the active caller.\n   * @returns {Promise<number>} Bytes removed.\n   */\n  async performCleanup(protectedDigests) {\n    const state = await this.loadState()\n    /** @type {Map<string, import(\"./types.js\").SynchronizedAssetCacheEntry[]>} */\n    const entriesByDigest = new Map()\n\n    for (const entry of state.assets) {\n      const digestEntries = entriesByDigest.get(entry.descriptor.digest) || []\n\n      digestEntries.push(entry)\n      entriesByDigest.set(entry.descriptor.digest, digestEntries)\n    }\n\n    /** @type {{byteSize: number, digest: string, lastAccessedAt: number}[]} */\n    const cachedBlobs = []\n    let cachedBytes = 0\n\n    for (const [digest, references] of entriesByDigest) {\n      const uri = await this.adapter.blobUri({accountId: this.accountId, digest})\n\n      if (!uri) {\n        for (const entry of references) {\n          if (entry.status === \"cached\") entry.status = \"missing\"\n        }\n        continue\n      }\n\n      const byteSize = references[0].descriptor.byteSize\n\n      cachedBytes += byteSize\n      cachedBlobs.push({\n        byteSize,\n        digest,\n        lastAccessedAt: Math.max(...references.map((entry) => entry.lastAccessedAt))\n      })\n    }\n\n    let removedBytes = 0\n\n    while (cachedBlobs.length > 0) {\n      if (cachedBytes <= this.maxBytes) break\n\n      for (const cachedBlob of cachedBlobs) {\n        const currentReferences = state.assets.filter((entry) => entry.descriptor.digest === cachedBlob.digest)\n\n        if (currentReferences.length > 0) {\n          cachedBlob.lastAccessedAt = Math.max(...currentReferences.map((entry) => entry.lastAccessedAt))\n        }\n      }\n\n      cachedBlobs.sort((left, right) => left.lastAccessedAt - right.lastAccessedAt || left.digest.localeCompare(right.digest))\n\n      const blob = cachedBlobs.shift()\n\n      if (!blob) throw new Error(\"Expected a synchronized asset cache eviction candidate\")\n      if (protectedDigests.has(blob.digest)) continue\n      let blobWasAlreadyMissing = false\n      let deletionChecked = false\n      const deleted = await this.deleteDigestIfInactive(blob.digest, async () => {\n        deletionChecked = true\n\n        if (!this.state) throw new Error(\"Cannot clean synchronized asset blobs before loading state\")\n\n        const currentUri = await this.adapter.blobUri({accountId: this.accountId, digest: blob.digest})\n        const currentReferences = this.state.assets.filter((entry) => entry.descriptor.digest === blob.digest)\n\n        if (!currentUri) {\n          blobWasAlreadyMissing = true\n\n          for (const entry of currentReferences) {\n            if (entry.status === \"cached\") entry.status = \"missing\"\n          }\n\n          return false\n        }\n        if (currentReferences.some((entry) => entry.descriptor.retention === \"durable\")) return false\n\n        await this.adapter.deleteBlob({accountId: this.accountId, digest: blob.digest})\n\n        for (const entry of currentReferences) {\n          entry.attempts = 0\n          entry.nextRetryAt = null\n          entry.status = \"missing\"\n        }\n\n        return true\n      })\n\n      if (!deletionChecked) this.cleanupRequiredAfterReleaseDigests.add(blob.digest)\n      if (blobWasAlreadyMissing) cachedBytes -= blob.byteSize\n      if (!deleted) continue\n\n      cachedBytes -= blob.byteSize\n      removedBytes += blob.byteSize\n    }\n\n    await this.saveState()\n\n    return removedBytes\n  }\n\n  /**\n   * Loads cache state once for this cache instance.\n   * @returns {Promise<import(\"./types.js\").SynchronizedAssetCacheState>} Loaded state.\n   */\n  async loadState() {\n    if (this.state) return this.state\n    if (this.statePromise) return await this.statePromise\n\n    this.statePromise = this.loadStateFromAdapter()\n\n    try {\n      this.state = await this.statePromise\n\n      return this.state\n    } finally {\n      this.statePromise = null\n    }\n  }\n\n  /**\n   * Loads and recovers persisted cache state.\n   * @returns {Promise<import(\"./types.js\").SynchronizedAssetCacheState>} Loaded state.\n   */\n  async loadStateFromAdapter() {\n    const loadedState = await this.adapter.loadState({accountId: this.accountId})\n\n    if (!loadedState) return {assets: [], pendingDeletionDigests: [], version: CACHE_STATE_VERSION}\n    if (loadedState.version !== CACHE_STATE_VERSION) {\n      throw new Error(`Unsupported synchronized asset cache state version: ${loadedState.version}`)\n    }\n\n    let recoveredInterruptedDownload = false\n\n    for (const entry of loadedState.assets) {\n      if (entry.status !== \"downloading\") continue\n\n      entry.attempts += 1\n      entry.nextRetryAt = this.nowMilliseconds()\n      entry.status = \"failed\"\n      recoveredInterruptedDownload = true\n    }\n\n    if (recoveredInterruptedDownload) {\n      await this.adapter.saveState({accountId: this.accountId, state: loadedState})\n    }\n\n    return loadedState\n  }\n\n  /**\n   * Persists the current cache state.\n   * @returns {Promise<void>} Resolves after state persistence.\n   */\n  async saveState() {\n    if (!this.state) throw new Error(\"Cannot save synchronized asset cache before loading state\")\n    const state = this.copyState(this.state)\n\n    const persist = async () => {\n      await this.adapter.saveState({accountId: this.accountId, state})\n    }\n\n    await this.serializeStatePersistence(persist)\n  }\n\n  /**\n   * Persists a detached reconciliation before exposing it through shared state.\n   * @param {object} args Reconciliation inputs.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheDescriptor[]} args.descriptors Current descriptors in the scope.\n   * @param {string} args.scopeKey Stable synchronized scope key.\n   * @returns {Promise<Map<string, import(\"./types.js\").SynchronizedAssetCacheEntry>>} Reconciled live entries by id.\n   */\n  async reconcileDescriptors({descriptors, scopeKey}) {\n    /** @type {Map<string, import(\"./types.js\").SynchronizedAssetCacheEntry> | null} */\n    let entriesById = null\n\n    const persist = async () => {\n      if (!this.state) throw new Error(\"Cannot reconcile synchronized asset cache before loading state\")\n\n      const candidateState = this.copyState(this.state)\n      const newEntryLastAccessedAt = this.nowMilliseconds()\n\n      this.applyDescriptorReconciliation({descriptors, newEntryLastAccessedAt, scopeKey, state: candidateState})\n      await this.adapter.saveState({accountId: this.accountId, state: candidateState})\n      entriesById = this.applyDescriptorReconciliation({descriptors, newEntryLastAccessedAt, scopeKey, state: this.state})\n    }\n\n    await this.serializeStatePersistence(persist)\n\n    if (!entriesById) throw new Error(\"Synchronized asset descriptor reconciliation completed without live entries\")\n\n    return entriesById\n  }\n\n  /**\n   * Applies one scope's descriptor set to cache state.\n   * @param {object} args Reconciliation inputs.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheDescriptor[]} args.descriptors Current descriptors in the scope.\n   * @param {number} args.newEntryLastAccessedAt Initial LRU timestamp for new entries.\n   * @param {string} args.scopeKey Stable synchronized scope key.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheState} args.state State to reconcile.\n   * @returns {Map<string, import(\"./types.js\").SynchronizedAssetCacheEntry>} Live entries by id.\n   */\n  applyDescriptorReconciliation({descriptors, newEntryLastAccessedAt, scopeKey, state}) {\n    const incomingIds = new Set(descriptors.map((asset) => asset.id))\n    const entriesById = new Map(state.assets.map((entry) => [entry.descriptor.id, entry]))\n    const descriptorsById = new Map(state.assets.map((entry) => [entry.descriptor.id, entry.descriptor]))\n    /** @type {Map<string, import(\"./types.js\").SynchronizedAssetCacheDescriptor>} */\n    const removedDescriptorsByDigest = new Map()\n\n    for (const asset of descriptors) {\n      const knownDescriptor = descriptorsById.get(asset.id)\n      const downloadFlight = this.downloadPromises.get(asset.digest)\n\n      if (knownDescriptor && knownDescriptor.digest !== asset.digest) {\n        throw new Error(`Synchronized asset descriptor ${asset.id} changed its immutable digest`)\n      }\n      if (knownDescriptor && knownDescriptor.byteSize !== asset.byteSize) {\n        throw new Error(`Synchronized asset descriptor ${asset.id} changed its immutable byte size`)\n      }\n      if (knownDescriptor && knownDescriptor.contentType !== asset.contentType) {\n        throw new Error(`Synchronized asset descriptor ${asset.id} changed its immutable content type`)\n      }\n      if (downloadFlight && downloadFlight.byteSize !== asset.byteSize) {\n        throw new Error(`Synchronized asset digest ${asset.digest} has inconsistent byte sizes`)\n      }\n      if (downloadFlight && downloadFlight.contentType !== asset.contentType) {\n        throw new Error(`Synchronized asset digest ${asset.digest} has inconsistent content types`)\n      }\n\n      descriptorsById.set(asset.id, asset)\n    }\n\n    for (const entry of state.assets) {\n      if (!entry.scopeKeys.includes(scopeKey) || incomingIds.has(entry.descriptor.id)) continue\n\n      entry.scopeKeys = entry.scopeKeys.filter((candidate) => candidate !== scopeKey)\n      if (entry.scopeKeys.length === 0) removedDescriptorsByDigest.set(entry.descriptor.digest, entry.descriptor)\n    }\n\n    state.assets = state.assets.filter((entry) => entry.scopeKeys.length > 0)\n\n    for (const asset of descriptors) {\n      const existing = entriesById.get(asset.id)\n\n      if (existing && state.assets.includes(existing)) {\n        existing.descriptor = asset\n        if (!existing.scopeKeys.includes(scopeKey)) existing.scopeKeys.push(scopeKey)\n      } else {\n        const newEntry = {\n          attempts: 0,\n          descriptor: asset,\n          lastAccessedAt: newEntryLastAccessedAt,\n          nextRetryAt: null,\n          scopeKeys: [scopeKey],\n          status: /** @type {const} */ (\"missing\")\n        }\n\n        state.assets.push(newEntry)\n        entriesById.set(asset.id, newEntry)\n      }\n    }\n\n    /** @type {Map<string, number>} */\n    const byteSizesByDigest = new Map()\n    /** @type {Map<string, string | null>} */\n    const contentTypesByDigest = new Map()\n\n    for (const entry of state.assets) {\n      const knownByteSize = byteSizesByDigest.get(entry.descriptor.digest)\n      const knownContentType = contentTypesByDigest.get(entry.descriptor.digest)\n\n      if (knownByteSize !== undefined && knownByteSize !== entry.descriptor.byteSize) {\n        throw new Error(`Synchronized asset digest ${entry.descriptor.digest} has inconsistent byte sizes`)\n      }\n      if (knownContentType !== undefined && knownContentType !== entry.descriptor.contentType) {\n        throw new Error(`Synchronized asset digest ${entry.descriptor.digest} has inconsistent content types`)\n      }\n\n      byteSizesByDigest.set(entry.descriptor.digest, entry.descriptor.byteSize)\n      contentTypesByDigest.set(entry.descriptor.digest, entry.descriptor.contentType)\n    }\n\n    for (const [digest, removedDescriptor] of removedDescriptorsByDigest) {\n      const retainedEntry = state.assets.find((entry) => entry.descriptor.digest === digest)\n\n      if (retainedEntry && retainedEntry.descriptor.byteSize === removedDescriptor.byteSize && retainedEntry.descriptor.contentType === removedDescriptor.contentType) continue\n      if (!state.pendingDeletionDigests.includes(digest)) state.pendingDeletionDigests.push(digest)\n    }\n\n    return entriesById\n  }\n\n  /**\n   * Copies metadata into a detached persistence candidate.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheState} state State to copy.\n   * @returns {import(\"./types.js\").SynchronizedAssetCacheState} Detached state.\n   */\n  copyState(state) {\n    return {\n      assets: state.assets.map((entry) => ({\n        ...entry,\n        descriptor: {...entry.descriptor},\n        scopeKeys: [...entry.scopeKeys]\n      })),\n      pendingDeletionDigests: [...state.pendingDeletionDigests],\n      version: state.version\n    }\n  }\n\n  /**\n   * Serializes one metadata persistence operation after prior failures or successes.\n   * @param {() => Promise<void>} persist Persistence operation.\n   * @returns {Promise<void>} Resolves after persistence.\n   */\n  async serializeStatePersistence(persist) {\n    this.saveStatePromise = this.saveStatePromise.then(persist, persist)\n\n    await this.saveStatePromise\n  }\n\n  /**\n   * Ensures one descriptor has verified local bytes.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheEntry} entry Descriptor state.\n   * @returns {Promise<{error: Error | null, uri: string | null}>} Cache result.\n   */\n  async ensureCached(entry) {\n    const digest = entry.descriptor.digest\n\n    await this.beginActiveDigest(digest)\n\n    try {\n      return await this.ensureCachedWhileActive([entry])\n    } finally {\n      await this.finishActiveDigest(digest)\n    }\n  }\n\n  /**\n   * Resolves or downloads descriptors sharing one protected digest.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheEntry[]} entries Descriptor states.\n   * @returns {Promise<{error: Error | null, uri: string | null}>} Cache result.\n   */\n  async ensureCachedWhileActive(entries) {\n    const entry = entries[0]\n\n    if (!entry) throw new Error(\"Cannot cache a synchronized asset digest without descriptor entries\")\n\n    const existingUri = await this.cachedUriWhileActive(entry)\n\n    if (existingUri) {\n      await this.recordCachedEntries(entries)\n\n      return {error: null, uri: existingUri}\n    }\n\n    const digest = entry.descriptor.digest\n    let downloadFlight = this.downloadPromises.get(digest)\n    let ownsDownloadPromise = false\n\n    if (downloadFlight) {\n      for (const digestEntry of entries) {\n        if (downloadFlight.byteSize !== digestEntry.descriptor.byteSize) {\n          throw new Error(`Synchronized asset digest ${digest} has inconsistent byte sizes`)\n        }\n        if (downloadFlight.contentType !== digestEntry.descriptor.contentType) {\n          throw new Error(`Synchronized asset digest ${digest} has inconsistent content types`)\n        }\n      }\n    }\n\n    for (const digestEntry of entries) digestEntry.status = \"downloading\"\n\n    if (!downloadFlight) {\n      downloadFlight = {\n        byteSize: entry.descriptor.byteSize,\n        contentType: entry.descriptor.contentType,\n        promise: this.downloadAfterPersistingState(entry.descriptor)\n      }\n      this.downloadPromises.set(digest, downloadFlight)\n      ownsDownloadPromise = true\n    } else {\n      await this.saveState()\n    }\n\n    try {\n      const cacheResult = await downloadFlight.promise\n\n      if (cacheResult.error) {\n        if (entry.status === \"downloading\") await this.recordDownloadFailure(digest)\n\n        return cacheResult\n      }\n\n      await this.recordCachedEntries(entries)\n\n      return cacheResult\n    } finally {\n      if (ownsDownloadPromise && this.downloadPromises.get(digest) === downloadFlight) {\n        this.downloadPromises.delete(digest)\n      }\n    }\n  }\n\n  /**\n   * Records one cached digest result for every participating descriptor.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheEntry[]} entries Descriptor states.\n   * @returns {Promise<void>} Resolves after persistence.\n   */\n  async recordCachedEntries(entries) {\n    if (!this.state) throw new Error(\"Cannot record synchronized asset cache results before loading state\")\n    const state = this.state\n    const lastAccessedAt = this.nowMilliseconds()\n\n    for (const entry of entries) {\n      entry.attempts = 0\n      entry.lastAccessedAt = lastAccessedAt\n      entry.nextRetryAt = null\n      entry.status = \"cached\"\n    }\n\n    const verifiedDigests = new Set(entries.map((entry) => entry.descriptor.digest))\n\n    state.pendingDeletionDigests = state.pendingDeletionDigests.filter((digest) => {\n      return !verifiedDigests.has(digest) || !state.assets.some((entry) => entry.descriptor.digest === digest)\n    })\n\n    await this.saveState()\n  }\n\n  /**\n   * Persists download intent, then downloads one digest and records a shared failure once.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheDescriptor} descriptor Asset descriptor.\n   * @returns {Promise<{error: Error, uri: null} | {error: null, uri: string}>} Shared cache result.\n   */\n  async downloadAfterPersistingState(descriptor) {\n    await this.saveState()\n\n    try {\n      return {error: null, uri: await this.downloadVerified(descriptor)}\n    } catch (error) {\n      const failure = error instanceof Error ? error : new Error(String(error))\n\n      await this.recordDownloadFailure(descriptor.digest)\n\n      return {error: failure, uri: null}\n    }\n  }\n\n  /**\n   * Advances retry metadata for every live descriptor sharing one failed digest.\n   * @param {string} digest Content digest.\n   * @returns {Promise<void>} Resolves after persistence.\n   */\n  async recordDownloadFailure(digest) {\n    if (!this.state) throw new Error(\"Cannot record synchronized asset download failure before loading state\")\n\n    const failedAt = this.nowMilliseconds()\n\n    for (const entry of this.state.assets) {\n      if (entry.descriptor.digest !== digest) continue\n      if (entry.status !== \"downloading\") continue\n\n      entry.attempts += 1\n      entry.nextRetryAt = failedAt + this.retryDelay(entry.attempts)\n      entry.status = \"failed\"\n    }\n\n    await this.saveState()\n  }\n\n  /**\n   * Downloads, verifies, and atomically persists one content digest.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheDescriptor} descriptor Asset descriptor.\n   * @returns {Promise<string>} Adapter URI.\n   */\n  async downloadVerified(descriptor) {\n    const downloadedBytes = await this.download(descriptor)\n\n    if (!(downloadedBytes instanceof Uint8Array)) {\n      throw new Error(`Synchronized asset ${descriptor.id} download did not return Uint8Array bytes`)\n    }\n    if (downloadedBytes.byteLength !== descriptor.byteSize) {\n      throw new Error(`Synchronized asset ${descriptor.id} byte size did not match its descriptor`)\n    }\n\n    const digest = `sha256-${sha256BytesHex(downloadedBytes)}`\n\n    if (digest !== descriptor.digest) {\n      throw new Error(`Synchronized asset ${descriptor.id} digest did not match its descriptor`)\n    }\n\n    const uri = await this.adapter.writeBlob({\n      accountId: this.accountId,\n      bytes: downloadedBytes,\n      contentType: descriptor.contentType,\n      digest\n    })\n\n    if (!uri) throw new Error(`Synchronized asset adapter returned no URI for ${descriptor.id}`)\n\n    return uri\n  }\n\n  /**\n   * Resolves an existing local URI after waiting for deletion work.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheEntry} entry Descriptor state.\n   * @returns {Promise<string | null>} Existing URI.\n   */\n  async cachedUri(entry) {\n    const digest = entry.descriptor.digest\n\n    while (true) {\n      await this.beginActiveDigest(digest)\n      let revalidationRequired\n      let uri\n\n      try {\n        uri = await this.cachedUriWhileActive(entry)\n      } finally {\n        revalidationRequired = await this.finishActiveDigest(digest)\n      }\n\n      if (!this.state) throw new Error(\"Cannot revalidate synchronized asset cache URI before loading state\")\n      if (!this.state.assets.some((candidate) => {\n        return candidate.descriptor.id === entry.descriptor.id && candidate.descriptor.digest === digest\n      })) return null\n      if (!revalidationRequired) return uri\n    }\n  }\n\n  /**\n   * Resolves an existing local URI while its digest is protected.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheEntry} entry Descriptor state.\n   * @returns {Promise<string | null>} Existing URI.\n   */\n  async cachedUriWhileActive(entry) {\n    if (!this.state) throw new Error(\"Cannot resolve synchronized asset cache URI before loading state\")\n    if (this.state.pendingDeletionDigests.includes(entry.descriptor.digest)) {\n      if (entry.status === \"cached\") entry.status = \"missing\"\n\n      return null\n    }\n\n    const uri = await this.adapter.blobUri({\n      accountId: this.accountId,\n      digest: entry.descriptor.digest\n    })\n\n    if (!uri && entry.status === \"cached\") entry.status = \"missing\"\n\n    return uri\n  }\n\n  /**\n   * Waits for deletion and protects a digest for one active cache operation.\n   * @param {string} digest Content digest.\n   * @returns {Promise<void>} Resolves after protection is registered.\n   */\n  async beginActiveDigest(digest) {\n    let deletionPromise = this.deletionPromises.get(digest)\n\n    while (deletionPromise) {\n      await deletionPromise\n      deletionPromise = this.deletionPromises.get(digest)\n    }\n\n    const activeCount = this.activeDigestCounts.get(digest) ?? 0\n\n    this.activeDigestCounts.set(digest, activeCount + 1)\n  }\n\n  /**\n   * Releases one cache operation and processes deferred deletion after the last.\n   * @param {string} digest Content digest.\n   * @param {Set<string>} [protectedCleanupDigests] Digests needed by the resolving caller.\n   * @returns {Promise<boolean>} Whether finalization requires URI revalidation.\n   */\n  async finishActiveDigest(digest, protectedCleanupDigests = new Set()) {\n    const activeCount = this.activeDigestCounts.get(digest)\n\n    if (activeCount === undefined) {\n      throw new Error(`Missing active synchronized asset digest count for ${digest}`)\n    }\n\n    if (activeCount > 1) {\n      this.activeDigestCounts.set(digest, activeCount - 1)\n      return false\n    }\n\n    this.activeDigestCounts.delete(digest)\n    const pendingDigestDeleted = await this.deletePendingDigestIfUnreferenced(digest)\n    const deferredCleanupRequired = this.cleanupRequiredAfterReleaseDigests.delete(digest)\n\n    if (deferredCleanupRequired) await this.cleanup(protectedCleanupDigests)\n\n    return pendingDigestDeleted || deferredCleanupRequired\n  }\n\n  /**\n   * Releases every acquired digest before propagating finalization failures.\n   * @param {string[]} digests Content digests.\n   * @returns {Promise<void>} Resolves after every digest is released.\n   */\n  async finishActiveDigests(digests) {\n    /** @type {Error[]} */\n    const failures = []\n\n    for (const digest of digests) {\n      try {\n        await this.finishActiveDigest(digest)\n      } catch (error) {\n        failures.push(error instanceof Error ? error : new Error(String(error)))\n      }\n    }\n\n    if (failures.length === 1) throw failures[0]\n    if (failures.length > 1) {\n      throw new AggregateError(failures, \"Multiple synchronized asset digest finalizers failed\", {cause: failures[0]})\n    }\n  }\n\n  /**\n   * Deletes blobs that lost their final descriptor reference.\n   * @returns {Promise<void>} Resolves after deletion.\n   */\n  async deleteUnreferencedDigests() {\n    if (!this.state) throw new Error(\"Cannot delete synchronized asset blobs before loading state\")\n\n    for (const digest of [...this.state.pendingDeletionDigests]) {\n      await this.deletePendingDigestIfUnreferenced(digest)\n    }\n  }\n\n  /**\n   * Deletes one persisted pending digest when no descriptor or active operation owns it.\n   * @param {string} digest Content digest.\n   * @returns {Promise<boolean>} Whether the blob was deleted.\n   */\n  async deletePendingDigestIfUnreferenced(digest) {\n    if (!this.state) throw new Error(\"Cannot delete synchronized asset blobs before loading state\")\n    if (!this.state.pendingDeletionDigests.includes(digest)) return false\n\n    return await this.deleteDigestIfInactive(digest, async () => {\n      if (!this.state) throw new Error(\"Cannot delete synchronized asset blobs before loading state\")\n      if (!this.state.pendingDeletionDigests.includes(digest)) return false\n      if (this.state.assets.some((entry) => entry.descriptor.digest === digest)) return false\n\n      await this.adapter.deleteBlob({accountId: this.accountId, digest})\n\n      const pendingDeletionDigests = this.state.pendingDeletionDigests\n\n      this.state.pendingDeletionDigests = pendingDeletionDigests.filter((candidate) => candidate !== digest)\n\n      try {\n        await this.saveState()\n      } catch (error) {\n        if (!this.state.pendingDeletionDigests.includes(digest)) this.state.pendingDeletionDigests.push(digest)\n        throw error\n      }\n\n      return true\n    })\n  }\n\n  /**\n   * Runs one deletion only after earlier deletion work and when no cache operation owns the digest.\n   * @param {string} digest Content digest.\n   * @param {() => Promise<boolean>} callback Protected deletion callback.\n   * @returns {Promise<boolean>} Whether the callback deleted the blob.\n   */\n  async deleteDigestIfInactive(digest, callback) {\n    let activeDeletionPromise = this.deletionPromises.get(digest)\n\n    while (activeDeletionPromise) {\n      await activeDeletionPromise\n      activeDeletionPromise = this.deletionPromises.get(digest)\n    }\n\n    if (this.activeDigestCounts.has(digest)) return false\n\n    /**\n     * Releases callers waiting for deletion completion.\n     * @type {() => void}\n     */\n    let releaseDeletion = () => {}\n    /**\n     * Blocks new digest activity until deletion completes.\n     * @type {Promise<void>}\n     */\n    const deletionPromise = new Promise((resolve) => {\n      releaseDeletion = () => resolve(undefined)\n    })\n\n    this.deletionPromises.set(digest, deletionPromise)\n\n    try {\n      return await callback()\n    } finally {\n      if (this.deletionPromises.get(digest) === deletionPromise) this.deletionPromises.delete(digest)\n      releaseDeletion()\n    }\n  }\n\n  /**\n   * Finds required assets without locally cached bytes.\n   * @param {string} scopeKey Synchronized scope to inspect.\n   * @returns {Promise<string[]>} Missing required descriptor ids.\n   */\n  async missingRequiredAssetIds(scopeKey) {\n    const state = await this.loadState()\n    /** @type {string[]} */\n    const missingAssetIds = []\n\n    for (const entry of state.assets) {\n      if (!entry.scopeKeys.includes(scopeKey)) continue\n      if (entry.descriptor.offlineRequirement !== \"required\") continue\n      if (await this.cachedUri(entry)) continue\n\n      missingAssetIds.push(entry.descriptor.id)\n    }\n\n    return missingAssetIds\n  }\n\n  /**\n   * Checks whether a failed or missing entry may be downloaded now.\n   * @param {import(\"./types.js\").SynchronizedAssetCacheEntry} entry Descriptor state.\n   * @returns {boolean} Whether the retry deadline has passed.\n   */\n  retryEligible(entry) {\n    return entry.status !== \"failed\" || entry.nextRetryAt === null || entry.nextRetryAt <= this.nowMilliseconds()\n  }\n\n  /**\n   * Calculates bounded exponential retry delay.\n   * @param {number} attempts Consecutive failures.\n   * @returns {number} Retry delay.\n   */\n  retryDelay(attempts) {\n    return Math.min(this.retryMaxDelayMs, this.retryBaseDelayMs * (2 ** Math.max(0, attempts - 1)))\n  }\n\n  /**\n   * Reads the injectable wall clock.\n   * @returns {number} Current epoch milliseconds.\n   */\n  nowMilliseconds() {\n    return this.now().getTime()\n  }\n}\n"]}