@faithfulalabi/agent-lens 0.1.0

package/dist/src/archive/mirror.js

@@ -0,0 +1,366 @@
+import { createHash } from 'node:crypto';
+import { closeSync, constants, fchmodSync, fstatSync, openSync, readSync, writeSync, } from 'node:fs';
+import { dirname } from 'node:path';
+import { discover } from './discover.js';
+import { acquireLock } from './lock.js';
+import { appendArchiveLog } from './log.js';
+import { sealArchiveFile } from './seal.js';
+import { assertNotUnderRoot, canonicalizeTranscriptPath, ensureDir, ensureDirUnder, realpathDeepest, refuseSymlinkedLeaf, resolveArchiveLogPath, resolveArchiveRoot, resolveDataDir, resolveTranscriptRoot, statSafe, statSafeBig, TRANSCRIPT_ROOT_LABEL, } from './paths.js';
+const { O_CREAT, O_EXCL, O_NOFOLLOW, O_RDONLY, O_RDWR, O_WRONLY } = constants;
+const PROBE_BYTES = 4096;
+const CHUNK_BYTES = 1024 * 1024;
+const NEWLINE = 0x0a;
+export function decideCopyEnd(input) {
+    const { archiveSize, sourceSize, lastNewlineOffset, settled } = input;
+    if (sourceSize <= archiveSize)
+        return archiveSize;
+    if (settled)
+        return sourceSize;
+    return lastNewlineOffset === undefined ? archiveSize : lastNewlineOffset + 1;
+}
+export function shouldSeal(input) {
+    const { sourceState, alreadySealed, archiveSize } = input;
+    return sourceState === 'expired' && !alreadySealed && archiveSize > 0;
+}
+function readInto(fd, buf, position, length) {
+    let read = 0;
+    while (read < length) {
+        const n = readSync(fd, buf, read, length - read, position + read);
+        if (n === 0)
+            break;
+        read += n;
+    }
+    return read;
+}
+export function readRange(fd, position, length) {
+    if (length <= 0)
+        return Buffer.alloc(0);
+    const buf = Buffer.allocUnsafe(length);
+    const read = readInto(fd, buf, position, length);
+    return read === length ? buf : buf.subarray(0, read);
+}
+function sha256(buf) {
+    return createHash('sha256').update(buf).digest('hex');
+}
+function hashPrefix(fd, length, buf) {
+    const hash = createHash('sha256');
+    let pos = 0;
+    let bytesRead = 0;
+    while (pos < length) {
+        const want = Math.min(buf.length, length - pos);
+        const got = readInto(fd, buf, pos, want);
+        if (got === 0)
+            break;
+        hash.update(buf.subarray(0, got));
+        pos += got;
+        bytesRead += got;
+    }
+    return { hash: hash.digest('hex'), bytesRead };
+}
+function scanDeltaBackward(fd, from, to, buf) {
+    let lastNewlineOffset;
+    let bytesRead = 0;
+    let end = to;
+    while (end > from) {
+        const start = Math.max(from, end - buf.length);
+        const want = end - start;
+        const got = readInto(fd, buf, start, want);
+        if (got === 0)
+            break;
+        bytesRead += got;
+        if (lastNewlineOffset === undefined) {
+            const idx = buf.subarray(0, got).lastIndexOf(NEWLINE);
+            if (idx !== -1)
+                lastNewlineOffset = start + idx;
+        }
+        end = start;
+    }
+    return { lastNewlineOffset, bytesRead };
+}
+function writeArchiveBytes(params) {
+    const { archiveRoot, archivePath, archiveExists, sourceFd, from, to, buffer } = params;
+    const dir = dirname(archivePath);
+    ensureDirUnder(dir, archiveRoot);
+    const fd = refuseSymlinkedLeaf(archivePath, () => openSync(archivePath, archiveExists ? O_RDWR | O_NOFOLLOW : O_WRONLY | O_CREAT | O_EXCL, 0o600));
+    try {
+        if (!archiveExists)
+            fchmodSync(fd, 0o600);
+        let pos = from;
+        let bytesRead = 0;
+        while (pos < to) {
+            const want = Math.min(buffer.length, to - pos);
+            const got = readInto(sourceFd, buffer, pos, want);
+            if (got === 0)
+                break;
+            bytesRead += got;
+            const size = fstatSync(fd).size;
+            if (size !== pos) {
+                throw new Error(`Invariant W violated for ${archivePath}: EOF is ${size} but the next write is at ${pos}`);
+            }
+            writeSync(fd, buffer, 0, got, pos);
+            pos += got;
+        }
+        return { bytesWritten: pos - from, bytesRead };
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function detectDivergence(params) {
+    const { sourceFd, archiveFd, sourceSize, archiveSize, verify, buffer } = params;
+    if (archiveSize === 0)
+        return { reason: undefined, bytesRead: 0 };
+    if (sourceSize < archiveSize)
+        return { reason: 'shrink', bytesRead: 0 };
+    let bytesRead = 0;
+    const w = Math.min(PROBE_BYTES, archiveSize);
+    const sourceHead = readRange(sourceFd, 0, w);
+    bytesRead += sourceHead.length;
+    const archiveHead = readRange(archiveFd, 0, w);
+    if (!sourceHead.equals(archiveHead))
+        return { reason: 'head', bytesRead };
+    if (archiveSize > PROBE_BYTES) {
+        const seamStart = archiveSize - PROBE_BYTES;
+        const sourceSeam = readRange(sourceFd, seamStart, PROBE_BYTES);
+        bytesRead += sourceSeam.length;
+        const archiveSeam = readRange(archiveFd, seamStart, PROBE_BYTES);
+        if (!sourceSeam.equals(archiveSeam))
+            return { reason: 'seam', bytesRead };
+    }
+    if (verify) {
+        const sourcePrefix = hashPrefix(sourceFd, archiveSize, buffer);
+        bytesRead += sourcePrefix.bytesRead;
+        const archivePrefix = hashPrefix(archiveFd, archiveSize, buffer);
+        if (sourcePrefix.hash !== archivePrefix.hash)
+            return { reason: 'verify', bytesRead };
+    }
+    return { reason: undefined, bytesRead };
+}
+export function createMirrorContext(params) {
+    return {
+        archiveRoot: params.archiveRoot,
+        verify: params.verify === true,
+        buffer: Buffer.allocUnsafe(CHUNK_BYTES),
+        statFile: params.statFile ?? statSafeBig,
+        bytesRead: 0,
+        sealed: [],
+    };
+}
+function expire(entry, base, ctx) {
+    const expired = { ...base, source_state: 'expired' };
+    if (!shouldSeal({
+        sourceState: 'expired',
+        alreadySealed: entry.sealed,
+        archiveSize: base.archive_size,
+    })) {
+        return expired;
+    }
+    const sealed = sealArchiveFile(base.archive_path, ctx.archiveRoot);
+    ctx.sealed.push(base.archive_path);
+    return {
+        ...expired,
+        archive_size: sealed.sealed_size,
+        archive_state: 'sealed',
+        archive_sha256: sealed.archive_sha256,
+        sealed_at: sealed.sealed_at,
+    };
+}
+export function mirrorFile(entry, ctx) {
+    const archiveDiskPath = entry.sealed ? `${entry.archivePath}.zst` : entry.archivePath;
+    const archiveStat = statSafe(archiveDiskPath);
+    const archiveSize = archiveStat?.size ?? 0;
+    const archiveState = entry.sealed ? 'sealed' : 'hot';
+    const base = {
+        source_path: entry.sourcePath,
+        source_size: null,
+        source_mtime_ms: null,
+        source_head_sha256: null,
+        source_head_len: 0,
+        source_state: 'present',
+        archive_path: entry.archivePath,
+        archive_size: archiveSize,
+        archive_state: archiveState,
+        bytes_copied: 0,
+    };
+    const s0 = ctx.statFile(entry.sourcePath);
+    if (s0 === undefined || !s0.isFile()) {
+        return expire(entry, base, ctx);
+    }
+    const sourceSize = Number(s0.size);
+    base.source_size = sourceSize;
+    base.source_mtime_ms = Number(s0.mtimeMs);
+    let sourceFd;
+    try {
+        sourceFd = openSync(entry.sourcePath, 'r');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return expire(entry, base, ctx);
+        }
+        throw error;
+    }
+    try {
+        const headLen = Math.min(PROBE_BYTES, sourceSize);
+        const head = readRange(sourceFd, 0, headLen);
+        base.source_head_len = head.length;
+        base.source_head_sha256 = sha256(head);
+        ctx.bytesRead += head.length;
+        if (entry.sealed)
+            return base;
+        if (archiveSize > 0 && archiveStat !== undefined) {
+            const archiveFd = refuseSymlinkedLeaf(archiveDiskPath, () => openSync(archiveDiskPath, O_RDONLY | O_NOFOLLOW));
+            let reason;
+            try {
+                const detected = detectDivergence({
+                    sourceFd,
+                    archiveFd,
+                    sourceSize,
+                    archiveSize,
+                    verify: ctx.verify,
+                    buffer: ctx.buffer,
+                });
+                reason = detected.reason;
+                ctx.bytesRead += detected.bytesRead;
+            }
+            finally {
+                closeSync(archiveFd);
+            }
+            if (reason !== undefined)
+                return { ...base, source_state: 'diverged', reason };
+        }
+        if (sourceSize <= archiveSize)
+            return base;
+        const scan = scanDeltaBackward(sourceFd, archiveSize, sourceSize, ctx.buffer);
+        ctx.bytesRead += scan.bytesRead;
+        const s1 = ctx.statFile(entry.sourcePath);
+        const settled = s1 !== undefined && s1.size === s0.size && s1.mtimeNs === s0.mtimeNs;
+        const end = decideCopyEnd({
+            archiveSize,
+            sourceSize,
+            lastNewlineOffset: scan.lastNewlineOffset,
+            settled,
+        });
+        if (end <= archiveSize)
+            return base;
+        const written = writeArchiveBytes({
+            archiveRoot: ctx.archiveRoot,
+            archivePath: entry.archivePath,
+            archiveExists: archiveStat !== undefined,
+            sourceFd,
+            from: archiveSize,
+            to: end,
+            buffer: ctx.buffer,
+        });
+        ctx.bytesRead += written.bytesRead;
+        return {
+            ...base,
+            archive_size: archiveSize + written.bytesWritten,
+            bytes_copied: written.bytesWritten,
+        };
+    }
+    finally {
+        closeSync(sourceFd);
+    }
+}
+function ensureContainedArchiveRoot(dataDir, sourceRoot) {
+    const resolvedDataDir = realpathDeepest(dataDir);
+    assertNotUnderRoot(resolvedDataDir, sourceRoot, TRANSCRIPT_ROOT_LABEL);
+    const root = resolveArchiveRoot(resolvedDataDir);
+    assertNotUnderRoot(root, sourceRoot, TRANSCRIPT_ROOT_LABEL);
+    ensureDir(root);
+    assertNotUnderRoot(root, sourceRoot, TRANSCRIPT_ROOT_LABEL);
+    return root;
+}
+export function archiveOnce(options = {}) {
+    const sourceRoot = canonicalizeTranscriptPath(resolveTranscriptRoot(options.transcriptRoot));
+    const dataDir = resolveDataDir(options.dataDir);
+    let archiveRoot;
+    let lock;
+    try {
+        archiveRoot = canonicalizeTranscriptPath(ensureContainedArchiveRoot(dataDir, sourceRoot));
+        lock = acquireLock(dataDir, options.lockIdentity);
+    }
+    catch (error) {
+        return {
+            files: [],
+            filesSeen: 0,
+            bytesCopied: 0,
+            bytesRead: 0,
+            lock: { state: 'not-attempted' },
+            errors: [{ path: dataDir, message: String(error), origin: 'archive' }],
+            sourceRoot,
+            archiveRoot: resolveArchiveRoot(dataDir),
+            logged: false,
+            sealed: [],
+        };
+    }
+    const result = {
+        files: [],
+        filesSeen: 0,
+        bytesCopied: 0,
+        bytesRead: 0,
+        lock: lock.state,
+        errors: [],
+        sourceRoot,
+        archiveRoot,
+        logged: false,
+        sealed: [],
+    };
+    const diverged = [];
+    const newlyExpired = [];
+    try {
+        if (lock.state.state !== 'held') {
+            const entries = discover(sourceRoot, archiveRoot);
+            result.filesSeen = entries.length;
+            const ctx = createMirrorContext({ archiveRoot, verify: options.verify });
+            for (const entry of entries) {
+                try {
+                    const state = mirrorFile(entry, ctx);
+                    result.files.push(state);
+                    result.bytesCopied += state.bytes_copied;
+                    if (state.source_state === 'diverged') {
+                        diverged.push({
+                            source_path: state.source_path,
+                            reason: state.reason ?? 'shrink',
+                            archive_size: state.archive_size,
+                            source_size: state.source_size,
+                        });
+                    }
+                    if (state.source_state === 'expired' && entry.presence !== 'archive-only') {
+                        newlyExpired.push(state.source_path);
+                    }
+                }
+                catch (error) {
+                    const origin = error.path === entry.sourcePath ? 'source' : 'archive';
+                    result.errors.push({ path: entry.sourcePath, message: String(error), origin });
+                }
+            }
+            result.bytesRead = ctx.bytesRead;
+            result.sealed = ctx.sealed;
+        }
+    }
+    finally {
+        lock.release();
+    }
+    const record = {
+        ts: new Date().toISOString(),
+        files_seen: result.filesSeen,
+        bytes_copied: result.bytesCopied,
+        lock: result.lock,
+        diverged,
+        newly_expired: newlyExpired,
+        errors: result.errors,
+        sealed: result.sealed,
+    };
+    try {
+        result.logged = appendArchiveLog(dataDir, record);
+    }
+    catch (error) {
+        result.errors.push({
+            path: resolveArchiveLogPath(dataDir),
+            message: String(error),
+            origin: 'log',
+        });
+    }
+    return result;
+}

package/dist/src/archive/paths.js

@@ -0,0 +1,159 @@
+import { closeSync, constants, fchmodSync, lstatSync, mkdirSync, openSync, realpathSync, statSync, writeSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+const { O_APPEND, O_CREAT, O_NOFOLLOW, O_WRONLY } = constants;
+const ARCHIVE_DIR = 'archive';
+const LOGS_DIR = 'logs';
+export function resolveDataDir(dir) {
+    return dir ?? process.env.AGENT_LENS_DIR ?? join(homedir(), '.agent-lens');
+}
+export function resolveTranscriptRoot(root) {
+    return root ?? process.env.AGENT_LENS_TRANSCRIPT_ROOT ?? join(homedir(), '.claude', 'projects');
+}
+export function canonicalizeTranscriptPath(path) {
+    try {
+        return realpathSync.native(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+export function realpathDeepest(path) {
+    const absolute = resolve(path);
+    const missing = [];
+    let current = absolute;
+    for (;;) {
+        try {
+            return join(realpathSync.native(current), ...missing);
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current)
+                return absolute;
+            missing.unshift(basename(current));
+            current = parent;
+        }
+    }
+}
+export function resolveArchiveRoot(dataDir) {
+    return join(resolveDataDir(dataDir), ARCHIVE_DIR);
+}
+export function resolveArchiveLogPath(dataDir) {
+    return join(resolveDataDir(dataDir), LOGS_DIR, 'archive.jsonl');
+}
+export function resolveLockPath(dataDir) {
+    return join(resolveDataDir(dataDir), 'archive.lock');
+}
+export function resolveCronLogPath(dataDir) {
+    return join(resolveDataDir(dataDir), LOGS_DIR, 'cron.log');
+}
+export function resolveLaunchAgentsDir(homeDir = homedir()) {
+    return join(homeDir, 'Library', 'LaunchAgents');
+}
+export function resolvePlistPath(label, homeDir = homedir()) {
+    return join(resolveLaunchAgentsDir(homeDir), `${label}.plist`);
+}
+export function resolveScheduleWrapperPath(dataDir) {
+    return join(resolveDataDir(dataDir), 'schedule', 'archive.sh');
+}
+function isUnder(path, root) {
+    return path === root || path.startsWith(root.endsWith(sep) ? root : root + sep);
+}
+const ARCHIVE_ROOT_LABEL = 'the archive root';
+export const DATA_DIR_LABEL = 'the data dir';
+export const TRANSCRIPT_ROOT_LABEL = 'the transcript root';
+export function assertUnderRoot(path, root, label) {
+    const resolved = realpathDeepest(path);
+    if (!isUnder(resolved, realpathDeepest(root))) {
+        throw new Error(`refusing to write outside ${label}: ${resolved}`);
+    }
+}
+export function assertNotUnderRoot(path, root, label) {
+    const resolved = realpathDeepest(path);
+    if (isUnder(resolved, realpathDeepest(root))) {
+        throw new Error(`refusing to write inside ${label}: ${resolved}`);
+    }
+}
+export function assertUnderArchiveRoot(path, archiveRoot) {
+    assertUnderRoot(path, archiveRoot, ARCHIVE_ROOT_LABEL);
+}
+export function isUnderAnyRoot(path, roots) {
+    if (roots.length === 0)
+        return false;
+    const resolvedRoots = roots.map((root) => realpathDeepest(root));
+    const contained = (candidate) => {
+        const resolved = realpathDeepest(candidate);
+        return resolvedRoots.some((root) => isUnder(resolved, root));
+    };
+    if (!contained(path))
+        return false;
+    return statSafe(path) !== undefined || contained(`${path}.zst`);
+}
+export function relativeUnder(root, path) {
+    const rel = relative(root, path);
+    if (rel === '' || isAbsolute(rel) || rel === '..' || rel.startsWith(`..${sep}`)) {
+        return undefined;
+    }
+    return rel;
+}
+export function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+export function ensureDirUnder(dir, root, label = ARCHIVE_ROOT_LABEL) {
+    assertUnderRoot(dir, root, label);
+    ensureDir(dir);
+    assertUnderRoot(dir, root, label);
+}
+export function lstatSafe(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function refuseSymlinkedLeaf(archivePath, open) {
+    try {
+        return open();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ELOOP') {
+            throw new Error(`refusing to follow a symlinked archive destination: ${archivePath} (ELOOP)`);
+        }
+        if (code === 'EEXIST') {
+            if (lstatSafe(archivePath)?.isSymbolicLink() === true) {
+                throw new Error(`refusing to follow a symlinked archive destination: ${archivePath} (EEXIST)`);
+            }
+            throw new Error(`archive destination already exists: ${archivePath} (EEXIST)`);
+        }
+        throw error;
+    }
+}
+export function appendOwnedLine(path, line, dataDir) {
+    ensureDirUnder(dirname(path), dataDir, DATA_DIR_LABEL);
+    const fd = refuseSymlinkedLeaf(path, () => openSync(path, O_WRONLY | O_CREAT | O_APPEND | O_NOFOLLOW, 0o600));
+    try {
+        fchmodSync(fd, 0o600);
+        writeSync(fd, line);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export function statSafe(path) {
+    try {
+        return statSync(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function statSafeBig(path) {
+    try {
+        return statSync(path, { bigint: true });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/archive/read.js

@@ -0,0 +1,133 @@
+import { closeSync, fstatSync, openSync, readFileSync } from 'node:fs';
+import { zstdDecompressSync } from 'node:zlib';
+import { readRange } from './mirror.js';
+const SEALED_SUFFIX = '.zst';
+const ZSTD_MAGIC = 0xfd2fb528;
+const DEFAULT_MAX_ENTRIES = 4;
+export const DEFAULT_MAX_BYTES = 64 * 1024 * 1024;
+export function declaredContentSize(frame, label) {
+    if (frame.length < 5 || frame.readUInt32LE(0) !== ZSTD_MAGIC) {
+        throw new Error(`not a zstd frame: ${label}`);
+    }
+    const descriptor = frame[4];
+    const contentSizeFlag = descriptor >> 6;
+    const singleSegment = (descriptor >> 5) & 1;
+    const dictionaryIdFlag = descriptor & 0b11;
+    const offset = 5 + (singleSegment === 1 ? 0 : 1) + [0, 1, 2, 4][dictionaryIdFlag];
+    const width = contentSizeFlag === 0 ? (singleSegment === 1 ? 1 : 0) : [0, 2, 4, 8][contentSizeFlag];
+    if (width === 0) {
+        throw new Error(`sealed archive declares no content size: ${label}`);
+    }
+    if (offset + width > frame.length) {
+        throw new Error(`truncated zstd frame header: ${label}`);
+    }
+    switch (width) {
+        case 1:
+            return frame.readUInt8(offset);
+        case 2:
+            return frame.readUInt16LE(offset) + 256;
+        case 4:
+            return frame.readUInt32LE(offset);
+        default:
+            return Number(frame.readBigUInt64LE(offset));
+    }
+}
+export function decompressSealedFrame(frame, declared, label, maxBytes) {
+    let out;
+    try {
+        out = zstdDecompressSync(frame, { maxOutputLength: maxBytes });
+    }
+    catch (error) {
+        if (error.code !== 'Z_BUF_ERROR')
+            throw error;
+        throw new Error(`truncated sealed archive ${label}: declares ${declared} bytes but 0 decompressed`);
+    }
+    if (out.length !== declared) {
+        throw new Error(`truncated sealed archive ${label}: declares ${declared} bytes but ${out.length} decompressed`);
+    }
+    return out;
+}
+export function createArchiveReader(options = {}) {
+    const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+    const cache = new Map();
+    let hits = 0;
+    let misses = 0;
+    let evictions = 0;
+    let cachedBytes = 0;
+    const openLogical = (archivePath) => {
+        try {
+            return { fd: openSync(archivePath, 'r'), sealed: false };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        try {
+            return { fd: openSync(`${archivePath}${SEALED_SUFFIX}`, 'r'), sealed: true };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            throw new Error(`no archived bytes for ${archivePath}`);
+        }
+    };
+    const loadSealed = (fd, archivePath) => {
+        const stat = fstatSync(fd, { bigint: true });
+        const key = `${archivePath}|${stat.ino}:${stat.mtimeNs}:${stat.size}`;
+        const cached = cache.get(key);
+        if (cached !== undefined) {
+            hits += 1;
+            cache.delete(key);
+            cache.set(key, cached);
+            return cached;
+        }
+        misses += 1;
+        const label = `${archivePath}${SEALED_SUFFIX}`;
+        const frame = readFileSync(fd);
+        const declared = declaredContentSize(frame, label);
+        if (declared > maxBytes) {
+            throw new Error(`sealed archive ${label} declares ${declared} bytes, over the ${maxBytes}-byte bound`);
+        }
+        const buf = decompressSealedFrame(frame, declared, label, maxBytes);
+        cache.set(key, buf);
+        cachedBytes += buf.length;
+        while (cache.size > maxEntries || cachedBytes > maxBytes) {
+            const oldest = cache.keys().next();
+            if (oldest.done === true)
+                break;
+            cachedBytes -= cache.get(oldest.value).length;
+            cache.delete(oldest.value);
+            evictions += 1;
+        }
+        return buf;
+    };
+    return {
+        read(archivePath, offset, length) {
+            const { fd, sealed } = openLogical(archivePath);
+            try {
+                if (!sealed)
+                    return readRange(fd, offset, length);
+                if (length <= 0)
+                    return Buffer.alloc(0);
+                const buf = loadSealed(fd, archivePath);
+                return Buffer.from(buf.subarray(offset, Math.min(offset + length, buf.length)));
+            }
+            finally {
+                closeSync(fd);
+            }
+        },
+        size(archivePath) {
+            const { fd, sealed } = openLogical(archivePath);
+            try {
+                return sealed ? loadSealed(fd, archivePath).length : fstatSync(fd).size;
+            }
+            finally {
+                closeSync(fd);
+            }
+        },
+        stats() {
+            return { hits, misses, evictions, entries: cache.size, bytes: cachedBytes };
+        },
+    };
+}