@agentunion/fastaun 0.5.21 → 0.5.23

package/dist/storage/read-cache.js

@@ -0,0 +1,625 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { StorageError } from './errors.js';
+const { DatabaseSync } = createRequire(import.meta.url)('node:sqlite');
+const METADATA_TTL_MS = 60_000;
+const MEMORY_LIMIT_BYTES = 32 * 1024 * 1024;
+const DISK_LIMIT_BYTES = 256 * 1024 * 1024;
+const METADATA_LIMIT_BYTES = 16 * 1024 * 1024;
+const MEMORY_LIMIT_COUNT = 999;
+const DISK_LIMIT_COUNT = 9_999;
+const caches = new WeakMap();
+const metadataMethods = new Set([
+    'storage.get_limits', 'storage.get_quota', 'storage.head_object',
+    'storage.list_objects', 'storage.list_prefixes', 'storage.get_folder',
+    'storage.list_children', 'storage.readlink', 'storage.list_acl',
+    'storage.resolve_path', 'storage.fs.list', 'storage.fs.stat',
+    'storage.fs.lstat', 'storage.fs.find', 'storage.fs.df',
+    'group.fs.ls', 'group.fs.find', 'group.fs.stat', 'group.fs.lstat',
+    'group.fs.get_acl', 'group.fs.list_acl', 'group.fs.df',
+]);
+const nonMutatingMethods = new Set([
+    ...metadataMethods, 'storage.get_object', 'storage.get_by_share',
+    'storage.check_upload', 'storage.create_upload_session',
+    'storage.create_download_ticket', 'storage.check_access',
+    'storage.list_tokens', 'storage.list_share_links',
+    'group.fs.check_upload', 'group.fs.create_upload_session',
+    'group.fs.create_download_ticket',
+]);
+const groupPermissionMethods = new Set([
+    'group.leave', 'group.kick', 'group.remove_member', 'group.add_member',
+    'group.set_role', 'group.dissolve', 'group.transfer_owner',
+    'group.ban', 'group.unban', 'group.block', 'group.unblock',
+    'group.suspend', 'group.resume',
+]);
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined)
+            .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+            .map(([key, item]) => [key, canonical(item)]));
+    }
+    return value;
+}
+export function storageCacheKey(method, params, loginAid = '') {
+    const identity = params._client_signature_identity;
+    const actor = String(identity?.aid ?? loginAid).trim().toLowerCase();
+    const businessParams = Object.fromEntries(Object.entries(params).filter(([key]) => ![
+        'no_cache', 'noCache', 'if_sha256', 'client_signature', '_client_signature_identity', 'device_id', 'slot_id', '_rpc_background',
+    ].includes(key)));
+    if (method === 'storage.get_object' || method === 'storage.create_download_ticket') {
+        businessParams.owner_aid ||= actor;
+        businessParams.bucket ||= 'default';
+    }
+    return createHash('sha256').update(JSON.stringify(canonical({ actor, method, params: businessParams }))).digest('hex');
+}
+function bodyMetadata(method, value) {
+    const result = structuredClone(value);
+    for (const key of ['content', 'content_base64', 'logical_url', 'download_url', 'upload_url', 'url', 'headers', 'token', 'access_token', 'share_id', 'share_token', 'client_signature', 'not_modified'])
+        delete result[key];
+    if (method.endsWith('.create_download_ticket'))
+        delete result.expire_at;
+    return result;
+}
+function hasExplicitSignature(params) {
+    return params.client_signature !== undefined;
+}
+function isRangeRequest(params) {
+    return ['offset', 'limit', 'range_start', 'range_end', 'head_bytes'].some((key) => params[key] !== undefined);
+}
+export function storageReadCache(client) {
+    const aid = String(client.aid ?? '').trim().toLowerCase();
+    const aunPath = resolve(client.aunPath || join(homedir(), '.aun'));
+    const gateway = String(client._gatewayUrl ?? '').trim();
+    const scope = `${aunPath}\0${aid}\0${gateway}`;
+    const current = caches.get(client);
+    if (current?.scope === scope)
+        return current.cache;
+    current?.cache.clearMemory();
+    const cache = new StorageReadCache(aid ? join(aunPath, '.cache', 'storage') : undefined, aid, gateway);
+    caches.set(client, { scope, cache });
+    return cache;
+}
+export function invalidateStorageReadCache(client, method) {
+    if (!(method.startsWith('storage.') || method.startsWith('group.fs.') || groupPermissionMethods.has(method)) || nonMutatingMethods.has(method))
+        return;
+    caches.get(client)?.cache.invalidate();
+}
+export class StorageReadCache {
+    scopeDirectory;
+    loginAid;
+    epoch = 0;
+    metadataEntries = new Map();
+    pending = new Map();
+    metadataContext = new AsyncLocalStorage();
+    bodyContext = new AsyncLocalStorage();
+    requestSequence = 0;
+    activeRequests = new Map();
+    bodyEntries = new Map();
+    memoryOrder = new Set();
+    memoryBytes = 0;
+    metadataBytes = 0;
+    hydrated = new Set();
+    initialized = false;
+    persistenceUnavailable = false;
+    blobDirectory;
+    namespace;
+    constructor(scopeDirectory, loginAid = '', gateway = '') {
+        this.scopeDirectory = scopeDirectory;
+        this.loginAid = loginAid;
+        if (scopeDirectory)
+            this.blobDirectory = join(scopeDirectory, 'blobs');
+        this.namespace = createHash('sha256').update(`${loginAid.trim().toLowerCase()}\0${gateway.trim()}`).digest('hex');
+    }
+    key(method, params) {
+        return `${this.namespace}:${storageCacheKey(method, params, this.loginAid)}`;
+    }
+    database(operation) {
+        if (!this.scopeDirectory || this.persistenceUnavailable)
+            return undefined;
+        let db;
+        try {
+            if (!this.initialized)
+                mkdirSync(this.scopeDirectory, { recursive: true });
+            db = new DatabaseSync(join(this.scopeDirectory, 'index.sqlite3'));
+            db.exec('PRAGMA busy_timeout = 5000');
+            db.exec('PRAGMA synchronous = NORMAL');
+            if (!this.initialized) {
+                db.exec('PRAGMA journal_mode = WAL');
+                db.exec('CREATE TABLE IF NOT EXISTS cache_entries(cache_key TEXT PRIMARY KEY,value_json TEXT NOT NULL,validated_at_ms INTEGER NOT NULL,expires_at_ms INTEGER NOT NULL)');
+                db.exec('CREATE TABLE IF NOT EXISTS cache_blobs(sha256 TEXT PRIMARY KEY,size_bytes INTEGER NOT NULL,last_access_ms INTEGER NOT NULL)');
+                this.initialized = true;
+            }
+            return operation(db);
+        }
+        catch {
+            this.persistenceUnavailable = true;
+            return undefined;
+        }
+        finally {
+            db?.close();
+        }
+    }
+    clearMemory() {
+        this.epoch += 1;
+        this.metadataEntries.clear();
+        this.bodyEntries.clear();
+        this.memoryOrder.clear();
+        this.hydrated.clear();
+        this.memoryBytes = 0;
+        this.metadataBytes = 0;
+        this.pending.clear();
+        this.activeRequests.clear();
+    }
+    invalidate() {
+        this.clearMemory();
+        this.database((db) => db.prepare('DELETE FROM cache_entries WHERE cache_key >= ? AND cache_key < ?').run(`${this.namespace}:`, `${this.namespace};`));
+    }
+    async rpc(method, params, noCache, loader) {
+        const key = this.key(method, params);
+        if ((method !== 'storage.get_object' && method !== 'storage.get_by_share') || isRangeRequest(params) || params.if_sha256 !== undefined || this.bodyContext.getStore()?.has(key)) {
+            return this.metadata(method, params, noCache, () => loader(params));
+        }
+        let original;
+        const body = await this.body(method, params, noCache, async (ifSha256) => {
+            original = await loader({ ...params, ...(ifSha256 ? { if_sha256: ifSha256 } : {}) });
+            return {
+                data: original.not_modified ? undefined : new Uint8Array(Buffer.from(String(original.content ?? original.content_base64 ?? ''), 'base64')),
+                sha256: String(original.sha256 ?? ''), metadata: original, notModified: original.not_modified === true,
+                cacheable: original.not_modified === true || original.download_url == null || original.content != null || original.content_base64 != null,
+            };
+        });
+        if (original && original.not_modified !== true)
+            return original;
+        if (body.rawResponse)
+            return body.rawResponse;
+        return { ...body.metadata, sha256: body.sha256, content: Buffer.from(body.data).toString('base64') };
+    }
+    async body(method, params, noCache, loader) {
+        const authoritative = params.consistency === 'authoritative' || hasExplicitSignature(params) || isRangeRequest(params);
+        const key = this.key(method, params);
+        const otherMethod = !authoritative
+            ? method === 'storage.get_object' ? 'storage.create_download_ticket' : method === 'storage.create_download_ticket' ? 'storage.get_object' : undefined
+            : undefined;
+        const otherKey = otherMethod ? this.key(otherMethod, params) : undefined;
+        const hot = this.bodyEntries.get(key);
+        const otherHot = otherKey ? this.bodyEntries.get(otherKey) : undefined;
+        const freshKey = hot && hot.expiresAt > Date.now() ? key : method === 'storage.create_download_ticket' && otherHot && otherHot.expiresAt > Date.now() ? otherKey : undefined;
+        if (!authoritative && !noCache && freshKey) {
+            const fresh = this.bodyEntries.get(freshKey);
+            this.bodyEntries.delete(freshKey);
+            this.bodyEntries.set(freshKey, fresh);
+            this.touchMemory(`body:${freshKey}`);
+            return structuredClone(fresh.value);
+        }
+        const epoch = this.epoch;
+        const pendingKey = `body:${epoch}:${noCache ? 'fresh' : 'normal'}:${key}`;
+        const pending = authoritative ? undefined : this.pending.get(pendingKey);
+        if (pending) {
+            const shared = await pending;
+            if (epoch === this.epoch && shared.expiresAt > Date.now())
+                return structuredClone(shared.value);
+            if (this.pending.get(pendingKey) === pending)
+                this.pending.delete(pendingKey);
+            return this.body(method, params, noCache, loader);
+        }
+        const requestKey = `${authoritative ? 'uncached' : 'body'}:${method === 'storage.create_download_ticket' && otherKey ? otherKey : key}`;
+        let sequence;
+        const request = (async () => {
+            const hydrationSequence = this.requestSequence;
+            const hydrationCurrent = () => epoch === this.epoch && hydrationSequence === this.requestSequence;
+            const restored = authoritative || this.bodyEntries.has(key) || this.hydrated.has(`body:${key}`) ? undefined : await this.hydrateBody(key, hydrationCurrent);
+            const otherRestored = !otherKey || this.bodyEntries.has(otherKey) || this.hydrated.has(`body:${otherKey}`) ? undefined : await this.hydrateBody(otherKey, hydrationCurrent);
+            const own = authoritative ? undefined : this.bodyEntries.get(key) ?? (hydrationCurrent() ? restored : undefined);
+            const other = otherKey ? this.bodyEntries.get(otherKey) ?? (hydrationCurrent() ? otherRestored : undefined) : undefined;
+            const cached = own && own.expiresAt > Date.now() ? own : other && other.expiresAt > Date.now() ? other : own ?? other;
+            if (!noCache && cached && cached.expiresAt > Date.now() && (cached === own || method === 'storage.create_download_ticket'))
+                return { value: cached.value, expiresAt: cached.expiresAt };
+            if (epoch === this.epoch)
+                sequence = this.beginRequest(requestKey);
+            const startedAt = Date.now();
+            const loaded = await this.bodyContext.run(new Set([...(this.bodyContext.getStore() ?? []), key]), () => loader(cached?.value.sha256));
+            const data = loaded.notModified ? cached?.value.data : loaded.data;
+            if (!data)
+                throw new StorageError('not_modified response requires verified cached content', 'ESTORAGE');
+            const hint = loaded.metadata.read_cache;
+            const sha256 = loaded.sha256.toLowerCase();
+            const validMaxAge = hint?.max_age_ms === undefined || typeof hint.max_age_ms === 'number' && Number.isFinite(hint.max_age_ms) && hint.max_age_ms > 0;
+            const safe = loaded.cacheable !== false && /^[0-9a-f]{64}$/.test(sha256) && (hint == null ? data.byteLength <= 65_536 : hint.inline === true && hint.reusable === true && validMaxAge);
+            if ((loaded.notModified || loaded.cacheable !== false && (safe || method === 'storage.get_object' || method === 'storage.get_by_share') && /^[0-9a-f]{64}$/.test(sha256)) && (!/^[0-9a-f]{64}$/.test(sha256) || (!loaded.notModified && createHash('sha256').update(data).digest('hex') !== sha256) || (loaded.notModified && cached?.value.sha256 !== sha256))) {
+                throw new StorageError('cached content hash verification failed', 'EHASH');
+            }
+            const value = { data: data.slice(), sha256, metadata: bodyMetadata(method, loaded.metadata) };
+            if (!safe && !loaded.notModified)
+                value.rawResponse = structuredClone(loaded.metadata);
+            const maxAge = hint?.max_age_ms === undefined ? METADATA_TTL_MS : validMaxAge ? Math.min(METADATA_TTL_MS, hint.max_age_ms) : 0;
+            const expiresAt = safe && maxAge > 0 ? startedAt + maxAge : 0;
+            if (!authoritative && sequence !== undefined && epoch === this.epoch && this.isCurrentRequest(requestKey, sequence)) {
+                this.requestSequence += 1;
+                this.detachBodyRequests(key, epoch);
+                this.deleteBody(key);
+                if (otherKey) {
+                    const expiresAt = safe && maxAge > 0 && other?.value.sha256 === sha256 ? startedAt + maxAge : 0;
+                    this.expireBodies([otherKey], epoch, expiresAt);
+                }
+                if (safe && maxAge > 0) {
+                    this.rememberBody(key, { value, expiresAt });
+                    await this.persistBody(key, value, expiresAt, epoch, sequence, requestKey);
+                }
+                else {
+                    this.deleteEntry(key);
+                }
+            }
+            return { value, expiresAt };
+        })();
+        if (!authoritative)
+            this.pending.set(pendingKey, request);
+        try {
+            return structuredClone((await request).value);
+        }
+        catch (error) {
+            if (!authoritative && sequence !== undefined && epoch === this.epoch && this.isCurrentRequest(requestKey, sequence)) {
+                this.requestSequence += 1;
+                this.expireBodies(otherKey ? [key, otherKey] : [key], epoch, 0);
+            }
+            throw error;
+        }
+        finally {
+            if (this.pending.get(pendingKey) === request)
+                this.pending.delete(pendingKey);
+            if (sequence !== undefined)
+                this.finishRequest(requestKey, epoch);
+        }
+    }
+    async metadata(method, params, noCache, loader) {
+        if (!metadataMethods.has(method) || params.consistency === 'authoritative' || hasExplicitSignature(params))
+            return loader();
+        const key = this.key(method, params);
+        if (this.metadataContext.getStore()?.has(key))
+            return loader();
+        const epoch = this.epoch;
+        if (!this.metadataEntries.has(key))
+            this.hydrateMetadata(key);
+        const cached = this.metadataEntries.get(key);
+        if (!noCache && cached && cached.expiresAt > Date.now()) {
+            this.metadataEntries.delete(key);
+            this.metadataEntries.set(key, cached);
+            this.touchMemory(`meta:${key}`);
+            return structuredClone(cached.value);
+        }
+        const pendingKey = `meta:${epoch}:${noCache ? 'fresh' : 'normal'}:${key}`;
+        const pending = this.pending.get(pendingKey);
+        if (pending) {
+            const shared = await pending;
+            if (epoch === this.epoch && shared.expiresAt > Date.now())
+                return structuredClone(shared.value);
+            if (this.pending.get(pendingKey) === pending)
+                this.pending.delete(pendingKey);
+            return this.metadata(method, params, noCache, loader);
+        }
+        const requestKey = `meta:${key}`;
+        const sequence = this.beginRequest(requestKey);
+        const request = (async () => {
+            const startedAt = Date.now();
+            const value = await this.metadataContext.run(new Set([...(this.metadataContext.getStore() ?? []), key]), loader);
+            const reusable = value && typeof value === 'object' && this.isReusable(value.read_cache);
+            const hint = reusable ? value.read_cache : undefined;
+            const expiresAt = reusable ? startedAt + (hint ? Math.min(METADATA_TTL_MS, Number(hint.max_age_ms === undefined ? METADATA_TTL_MS : hint.max_age_ms)) : METADATA_TTL_MS) : 0;
+            if (epoch === this.epoch && this.isCurrentRequest(requestKey, sequence)) {
+                this.detachMetadataRequests(key, epoch);
+                if (reusable) {
+                    this.rememberMetadata(key, value, expiresAt);
+                    this.persistEntry(key, { kind: 'metadata', value }, expiresAt);
+                    this.trimDiskMetadata();
+                }
+                else {
+                    this.deleteMetadata(key);
+                    this.deleteEntry(key);
+                }
+            }
+            return { value, expiresAt };
+        })();
+        this.pending.set(pendingKey, request);
+        try {
+            return structuredClone((await request).value);
+        }
+        catch (error) {
+            if (epoch === this.epoch && this.isCurrentRequest(requestKey, sequence)) {
+                this.detachMetadataRequests(key, epoch);
+                this.deleteMetadata(key);
+                this.deleteEntry(key);
+            }
+            throw error;
+        }
+        finally {
+            if (this.pending.get(pendingKey) === request)
+                this.pending.delete(pendingKey);
+            this.finishRequest(requestKey, epoch);
+        }
+    }
+    isReusable(value) {
+        if (value == null)
+            return true;
+        if (!value || typeof value !== 'object')
+            return false;
+        const policy = value;
+        return policy.reusable === true && (policy.max_age_ms === undefined || typeof policy.max_age_ms === 'number' && Number.isFinite(policy.max_age_ms) && policy.max_age_ms > 0);
+    }
+    beginRequest(key) {
+        const sequence = ++this.requestSequence;
+        this.activeRequests.set(key, { sequence, count: (this.activeRequests.get(key)?.count ?? 0) + 1, epoch: this.epoch });
+        return sequence;
+    }
+    isCurrentRequest(key, sequence) {
+        return this.activeRequests.get(key)?.sequence === sequence;
+    }
+    finishRequest(key, epoch) {
+        const state = this.activeRequests.get(key);
+        if (state?.epoch === epoch && --state.count === 0)
+            this.activeRequests.delete(key);
+    }
+    expireBodies(keys, epoch, expiresAt) {
+        for (const key of keys) {
+            const entry = this.bodyEntries.get(key);
+            if (entry)
+                entry.expiresAt = Math.min(entry.expiresAt, expiresAt);
+            this.detachBodyRequests(key, epoch);
+        }
+        this.database((db) => {
+            const update = db.prepare('UPDATE cache_entries SET expires_at_ms = MIN(expires_at_ms, ?) WHERE cache_key = ?');
+            for (const key of keys)
+                update.run(expiresAt, key);
+        });
+    }
+    detachBodyRequests(key, epoch) {
+        this.pending.delete(`body:${epoch}:normal:${key}`);
+        this.pending.delete(`body:${epoch}:fresh:${key}`);
+    }
+    detachMetadataRequests(key, epoch) {
+        this.pending.delete(`meta:${epoch}:normal:${key}`);
+        this.pending.delete(`meta:${epoch}:fresh:${key}`);
+    }
+    entry(key) {
+        return this.database((db) => db.prepare('SELECT value_json,expires_at_ms FROM cache_entries WHERE cache_key = ?').get(key));
+    }
+    deleteEntry(key) {
+        this.database((db) => db.prepare('DELETE FROM cache_entries WHERE cache_key = ?').run(key));
+    }
+    hydrateMetadata(key) {
+        if (this.hydrated.has(`meta:${key}`))
+            return;
+        this.markHydrated(`meta:${key}`);
+        const row = this.entry(key);
+        if (!row)
+            return;
+        try {
+            const parsed = JSON.parse(row.value_json);
+            if (row.expires_at_ms > Date.now() && parsed.kind === 'metadata' && parsed.value && this.isReusable(parsed.value.read_cache)) {
+                this.rememberMetadata(key, parsed.value, Number(row.expires_at_ms));
+            }
+            else
+                this.deleteEntry(key);
+        }
+        catch {
+            this.deleteEntry(key);
+        }
+    }
+    async hydrateBody(key, isCurrent) {
+        if (this.hydrated.has(`body:${key}`))
+            return undefined;
+        this.markHydrated(`body:${key}`);
+        if (!this.blobDirectory)
+            return undefined;
+        const row = this.entry(key);
+        if (!row)
+            return undefined;
+        let blobHash;
+        try {
+            const parsed = JSON.parse(row.value_json);
+            const hint = parsed.metadata?.read_cache;
+            if (parsed.kind !== 'body' || !parsed.metadata || !parsed.sha256 || !/^[0-9a-f]{64}$/.test(parsed.sha256) || hint != null && (hint.inline !== true || !this.isReusable(hint)))
+                throw new Error('invalid cached entry');
+            blobHash = parsed.sha256;
+            const data = await readFile(join(this.blobDirectory, parsed.sha256.slice(0, 2), parsed.sha256));
+            if (hint == null && data.byteLength > 65_536 || createHash('sha256').update(data).digest('hex') !== parsed.sha256)
+                throw new Error('invalid cached blob');
+            const entry = { value: { data: new Uint8Array(data), sha256: parsed.sha256, metadata: parsed.metadata }, expiresAt: Number(row.expires_at_ms) };
+            if (!isCurrent())
+                return undefined;
+            this.rememberBody(key, entry);
+            this.database((db) => db.prepare('UPDATE cache_blobs SET last_access_ms = ? WHERE sha256 = ?').run(Date.now(), parsed.sha256));
+            return entry;
+        }
+        catch {
+            if (isCurrent()) {
+                if (blobHash) {
+                    this.database((db) => {
+                        db.exec('BEGIN IMMEDIATE');
+                        try {
+                            const blobPath = join(this.blobDirectory, blobHash.slice(0, 2), blobHash);
+                            let repaired = false;
+                            try {
+                                repaired = createHash('sha256').update(readFileSync(blobPath)).digest('hex') === blobHash;
+                            }
+                            catch { }
+                            if (!repaired) {
+                                rmSync(blobPath, { force: true });
+                                db.prepare('DELETE FROM cache_entries WHERE json_extract(value_json,\'$.sha256\') = ?').run(blobHash);
+                                db.prepare('DELETE FROM cache_blobs WHERE sha256 = ?').run(blobHash);
+                            }
+                            db.exec('COMMIT');
+                        }
+                        catch (error) {
+                            db.exec('ROLLBACK');
+                            throw error;
+                        }
+                    });
+                }
+                else
+                    this.deleteEntry(key);
+            }
+            return undefined;
+        }
+    }
+    rememberBody(key, entry) {
+        this.deleteBody(key);
+        entry.metadataSize = Buffer.byteLength(JSON.stringify(entry.value.metadata), 'utf8');
+        if (entry.value.data.byteLength > MEMORY_LIMIT_BYTES || entry.metadataSize > METADATA_LIMIT_BYTES)
+            return;
+        this.bodyEntries.set(key, entry);
+        this.memoryBytes += entry.value.data.byteLength;
+        this.metadataBytes += entry.metadataSize;
+        this.touchMemory(`body:${key}`);
+        this.trimMemoryMetadata();
+        while (this.memoryBytes > MEMORY_LIMIT_BYTES) {
+            const oldest = this.bodyEntries.keys().next().value;
+            this.deleteBody(oldest);
+            this.hydrated.delete(`body:${oldest}`);
+        }
+    }
+    deleteBody(key) {
+        const prior = this.bodyEntries.get(key);
+        if (prior) {
+            this.memoryBytes -= prior.value.data.byteLength;
+            this.metadataBytes -= prior.metadataSize ?? 0;
+        }
+        this.bodyEntries.delete(key);
+        this.memoryOrder.delete(`body:${key}`);
+    }
+    rememberMetadata(key, value, expiresAt) {
+        this.deleteMetadata(key);
+        const size = Buffer.byteLength(JSON.stringify(value), 'utf8');
+        if (size <= METADATA_LIMIT_BYTES) {
+            this.metadataEntries.set(key, { value: structuredClone(value), expiresAt, size });
+            this.metadataBytes += size;
+            this.touchMemory(`meta:${key}`);
+        }
+        this.trimMemoryMetadata();
+    }
+    deleteMetadata(key) {
+        const prior = this.metadataEntries.get(key);
+        if (prior)
+            this.metadataBytes -= prior.size;
+        this.metadataEntries.delete(key);
+        this.memoryOrder.delete(`meta:${key}`);
+    }
+    touchMemory(key) {
+        this.memoryOrder.delete(key);
+        this.memoryOrder.add(key);
+    }
+    markHydrated(key) {
+        this.hydrated.add(key);
+        if (this.hydrated.size > MEMORY_LIMIT_COUNT)
+            this.hydrated.delete(this.hydrated.values().next().value);
+    }
+    trimMemoryMetadata() {
+        while (this.memoryOrder.size > MEMORY_LIMIT_COUNT || this.metadataBytes > METADATA_LIMIT_BYTES) {
+            const oldest = this.memoryOrder.values().next().value;
+            if (oldest.startsWith('body:'))
+                this.deleteBody(oldest.slice(5));
+            else
+                this.deleteMetadata(oldest.slice(5));
+            this.hydrated.delete(oldest);
+        }
+    }
+    persistEntry(key, value, expiresAt, database) {
+        const persist = (db) => db.prepare('INSERT INTO cache_entries(cache_key,value_json,validated_at_ms,expires_at_ms) VALUES(?,?,?,?) ON CONFLICT(cache_key) DO UPDATE SET value_json=excluded.value_json,validated_at_ms=excluded.validated_at_ms,expires_at_ms=excluded.expires_at_ms').run(key, JSON.stringify(value), Date.now(), expiresAt);
+        if (database)
+            persist(database);
+        else
+            this.database(persist);
+    }
+    async persistBody(key, value, expiresAt, epoch, sequence, requestKey = `body:${key}`) {
+        if (!this.blobDirectory || this.persistenceUnavailable)
+            return;
+        const blobDir = join(this.blobDirectory, value.sha256.slice(0, 2));
+        const blobPath = join(blobDir, value.sha256);
+        let tempPath;
+        try {
+            const known = this.database((db) => Boolean(db.prepare('SELECT 1 FROM cache_blobs WHERE sha256 = ?').get(value.sha256)));
+            if (this.persistenceUnavailable)
+                return;
+            if (!known) {
+                await mkdir(blobDir, { recursive: true });
+                tempPath = `${blobPath}.${process.pid}.${randomUUID()}.tmp`;
+                await writeFile(tempPath, value.data, { flag: 'wx' });
+            }
+            this.database((db) => {
+                db.exec('BEGIN IMMEDIATE');
+                let published = false;
+                try {
+                    if (!db.prepare('SELECT 1 FROM cache_blobs WHERE sha256 = ?').get(value.sha256)) {
+                        if (tempPath)
+                            renameSync(tempPath, blobPath);
+                        else {
+                            mkdirSync(blobDir, { recursive: true });
+                            writeFileSync(blobPath, value.data);
+                        }
+                        published = true;
+                    }
+                    db.prepare('INSERT INTO cache_blobs(sha256,size_bytes,last_access_ms) VALUES(?,?,?) ON CONFLICT(sha256) DO UPDATE SET last_access_ms=excluded.last_access_ms').run(value.sha256, value.data.byteLength, Date.now());
+                    if (epoch === this.epoch && this.isCurrentRequest(requestKey, sequence))
+                        this.persistEntry(key, { kind: 'body', sha256: value.sha256, metadata: value.metadata }, expiresAt, db);
+                    this.trimDiskMetadata(db);
+                    this.evictDisk(db);
+                    db.exec('COMMIT');
+                }
+                catch (error) {
+                    if (published)
+                        rmSync(blobPath, { force: true });
+                    db.exec('ROLLBACK');
+                    throw error;
+                }
+            });
+        }
+        catch {
+            if (epoch === this.epoch && this.isCurrentRequest(requestKey, sequence))
+                this.deleteEntry(key);
+        }
+        finally {
+            if (tempPath)
+                await unlink(tempPath).catch(() => undefined);
+        }
+    }
+    evictDisk(db) {
+        const totals = db.prepare('SELECT COUNT(*) AS count,COALESCE(SUM(size_bytes),0) AS total FROM cache_blobs').get();
+        let count = Number(totals.count);
+        let total = Number(totals.total);
+        while (count > DISK_LIMIT_COUNT || total > DISK_LIMIT_BYTES) {
+            const row = db.prepare('SELECT sha256,size_bytes FROM cache_blobs ORDER BY last_access_ms ASC LIMIT 1').get();
+            if (!row)
+                break;
+            rmSync(join(this.blobDirectory, row.sha256.slice(0, 2), row.sha256), { force: true });
+            db.prepare('DELETE FROM cache_entries WHERE json_extract(value_json,\'$.sha256\') = ?').run(row.sha256);
+            db.prepare('DELETE FROM cache_blobs WHERE sha256 = ?').run(row.sha256);
+            count -= 1;
+            total -= Number(row.size_bytes);
+        }
+    }
+    trimDiskMetadata(database) {
+        const trim = (db) => {
+            const totals = db.prepare('SELECT COUNT(*) AS count,COALESCE(SUM(length(CAST(value_json AS BLOB))),0) AS size FROM cache_entries').get();
+            let count = Number(totals.count);
+            let size = Number(totals.size);
+            while (count > DISK_LIMIT_COUNT || size > METADATA_LIMIT_BYTES) {
+                const oldest = db.prepare('SELECT cache_key,length(CAST(value_json AS BLOB)) AS size FROM cache_entries ORDER BY validated_at_ms ASC,cache_key ASC LIMIT 1').get();
+                if (!oldest)
+                    break;
+                db.prepare('DELETE FROM cache_entries WHERE cache_key = ?').run(oldest.cache_key);
+                count -= 1;
+                size -= Number(oldest.size);
+            }
+        };
+        if (database)
+            trim(database);
+        else
+            this.database(trim);
+    }
+}
+//# sourceMappingURL=read-cache.js.map