sneakoscope 7.3.0 → 7.6.0

package/dist/core/triwiki/context-graph/query/seeds.js

@@ -0,0 +1,241 @@
+import { compareContextGraphIds, contextGraphNodeId } from '../ids.js';
+import { isWorkspaceRelativePosixPath } from '../paths.js';
+import { contextGraphSeedConfidenceScore, isExactContextGraphSeedConfidence } from './ranking-config.js';
+const TOKEN_PATTERN = /[A-Za-z0-9_$@#./:-]+/g;
+const TRIM_PATTERN = /^[.:/-]+|[.:/-]+$/g;
+const PROBE_KINDS = [
+    'file',
+    'module',
+    'command',
+    'route',
+    'pipeline',
+    'gate',
+    'schema',
+    'wiki_claim',
+    'source',
+    'proof',
+    'risk_domain'
+];
+function probeIdentity(kind, token) {
+    switch (kind) {
+        case 'file':
+            return { kind: 'file', path: token };
+        case 'module':
+            return { kind: 'module', moduleId: token };
+        case 'command':
+            return { kind: 'command', name: token };
+        case 'route':
+            return { kind: 'route', name: token };
+        case 'pipeline':
+            return { kind: 'pipeline', pipelineId: token };
+        case 'gate':
+            return { kind: 'gate', gateId: token };
+        case 'schema':
+            return { kind: 'schema', schemaId: token };
+        case 'wiki_claim':
+            return { kind: 'wiki_claim', claimHash: token };
+        case 'source':
+            return { kind: 'source', sourceHash: token };
+        case 'proof':
+            return { kind: 'proof', proofId: token };
+        case 'risk_domain':
+            return { kind: 'risk_domain', domain: token };
+        default:
+            return null;
+    }
+}
+const MANIFEST_KINDS = new Set([
+    'command',
+    'gate',
+    'route',
+    'pipeline',
+    'schema'
+]);
+const PATH_KINDS = new Set(['file', 'test', 'config']);
+export function seedConfidenceFor(kind, match) {
+    if (match === 'path')
+        return 'file_path';
+    if (kind === 'symbol')
+        return 'exact_definition';
+    if (MANIFEST_KINDS.has(kind))
+        return 'manifest';
+    if (PATH_KINDS.has(kind))
+        return 'file_path';
+    return 'exact_reference';
+}
+export function normalizeContextGraphQuery(query, config) {
+    const normalized = String(query ?? '').normalize('NFKC').trim();
+    const tokens = [];
+    const seen = new Set();
+    for (const raw of normalized.match(TOKEN_PATTERN) ?? []) {
+        const token = raw.replace(TRIM_PATTERN, '');
+        if (!token || seen.has(token))
+            continue;
+        seen.add(token);
+        tokens.push(token);
+        if (tokens.length >= config.maxQueryTokens)
+            break;
+    }
+    return { normalized, tokens, lowerTokens: tokens.map((token) => token.toLowerCase()) };
+}
+class SeedCollector {
+    index;
+    config;
+    drafts = new Map();
+    constructor(index, config) {
+        this.index = index;
+        this.config = config;
+    }
+    add(nodeId, confidence, origin, score) {
+        const node = this.index.nodesById.get(nodeId);
+        if (!node)
+            return;
+        const resolved = score ?? contextGraphSeedConfidenceScore(this.config, confidence);
+        const existing = this.drafts.get(nodeId);
+        if (existing && existing.score >= resolved)
+            return;
+        const draft = {
+            nodeId,
+            confidence,
+            origin,
+            score: resolved,
+            ...(node.path === undefined ? {} : { path: node.path }),
+            ...(node.locator?.line === undefined ? {} : { line: node.locator.line })
+        };
+        this.drafts.set(nodeId, draft);
+    }
+}
+function addExactSeedsForToken(collector, index, token, config) {
+    const direct = index.nodesById.get(token);
+    if (direct)
+        collector.add(direct.id, seedConfidenceFor(direct.kind, 'node_id'), 'exact');
+    for (const kind of PROBE_KINDS) {
+        const identity = probeIdentity(kind, token);
+        if (!identity)
+            continue;
+        let probed;
+        try {
+            probed = contextGraphNodeId(identity);
+        }
+        catch {
+            continue;
+        }
+        const node = index.nodesById.get(probed);
+        if (node)
+            collector.add(node.id, seedConfidenceFor(node.kind, 'node_id'), 'exact');
+    }
+    const candidatePath = token.replace(/^\.\//, '');
+    if (isWorkspaceRelativePosixPath(candidatePath)) {
+        const atPath = index.nodesByPath.get(candidatePath) ?? [];
+        let added = 0;
+        for (const pass of [true, false]) {
+            for (const id of atPath) {
+                if (added >= config.maxSeedsPerToken)
+                    break;
+                const node = index.nodesById.get(id);
+                if (!node || PATH_KINDS.has(node.kind) !== pass)
+                    continue;
+                collector.add(node.id, 'file_path', 'exact');
+                added += 1;
+            }
+        }
+    }
+    const byLabel = index.nodesByLabel.get(token.toLowerCase()) ?? [];
+    for (const id of byLabel.slice(0, config.maxSeedsPerToken)) {
+        const node = index.nodesById.get(id);
+        if (node)
+            collector.add(node.id, seedConfidenceFor(node.kind, 'label'), 'exact');
+    }
+}
+function sweepLexicalSeeds(collector, index, query, config) {
+    const needles = query.lowerTokens.filter((token) => token.length >= config.lexicalMinTokenLength);
+    const sweep = { scanned: 0, budgetExhausted: false, added: 0 };
+    if (needles.length === 0)
+        return sweep;
+    const hits = [];
+    const consider = (keys, idsOf) => {
+        for (const key of keys) {
+            if (sweep.scanned >= config.lexicalScanBudget) {
+                sweep.budgetExhausted = true;
+                return;
+            }
+            sweep.scanned += 1;
+            const lower = key.toLowerCase();
+            if (!needles.some((needle) => lower.includes(needle)))
+                continue;
+            for (const id of idsOf(key))
+                hits.push(id);
+        }
+    };
+    consider(index.nodesByLabel.keys(), (key) => index.nodesByLabel.get(key) ?? []);
+    if (!sweep.budgetExhausted)
+        consider(index.nodesByPath.keys(), (key) => index.nodesByPath.get(key) ?? []);
+    const ordered = [...new Set(hits)].sort(compareContextGraphIds).slice(0, config.maxLexicalSeeds);
+    for (const id of ordered) {
+        if (collector.drafts.has(id))
+            continue;
+        collector.add(id, 'text_candidate', 'lexical', config.lexicalMatchScore);
+        sweep.added += 1;
+    }
+    return sweep;
+}
+function toSeed(draft) {
+    return {
+        nodeId: draft.nodeId,
+        confidence: draft.confidence,
+        origin: draft.origin,
+        score: draft.score,
+        ...(draft.path === undefined ? {} : { path: draft.path }),
+        ...(draft.line === undefined ? {} : { line: draft.line })
+    };
+}
+export function resolveContextGraphSeeds(input) {
+    const { index, request, config, maxSeeds } = input;
+    const query = normalizeContextGraphQuery(request.query, config);
+    const collector = new SeedCollector(index, config);
+    let unknownProvidedSeeds = 0;
+    let providedSeedCount = 0;
+    for (const seed of request.seeds ?? []) {
+        if (!index.nodesById.has(seed.nodeId)) {
+            unknownProvidedSeeds += 1;
+            continue;
+        }
+        const score = seed.score === undefined
+            ? contextGraphSeedConfidenceScore(config, seed.confidence)
+            : Math.min(seed.score, config.providedSeedScoreCeiling);
+        collector.add(seed.nodeId, seed.confidence, seed.origin ?? 'provided', score);
+        providedSeedCount += 1;
+    }
+    for (const focus of request.focusPaths ?? []) {
+        const normalized = String(focus ?? '').replace(/^\.\//, '');
+        if (!isWorkspaceRelativePosixPath(normalized))
+            continue;
+        for (const id of (index.nodesByPath.get(normalized) ?? []).slice(0, config.maxSeedsPerToken)) {
+            collector.add(id, 'file_path', 'exact');
+        }
+    }
+    for (const token of query.tokens)
+        addExactSeedsForToken(collector, index, token, config);
+    let exactSeedCount = 0;
+    for (const draft of collector.drafts.values()) {
+        if (isExactContextGraphSeedConfidence(draft.confidence))
+            exactSeedCount += 1;
+    }
+    let sweep = { scanned: 0, budgetExhausted: false, added: 0 };
+    if (exactSeedCount < config.minExactSeeds)
+        sweep = sweepLexicalSeeds(collector, index, query, config);
+    const ranked = [...collector.drafts.values()].sort((left, right) => right.score - left.score || compareContextGraphIds(left.nodeId, right.nodeId));
+    const kept = ranked.slice(0, Math.max(0, maxSeeds));
+    const seeds = kept.map(toSeed);
+    return {
+        seeds,
+        exactSeedCount: seeds.filter((seed) => isExactContextGraphSeedConfidence(seed.confidence)).length,
+        lexicalSeedCount: seeds.filter((seed) => seed.origin === 'lexical').length,
+        providedSeedCount,
+        unknownProvidedSeeds,
+        droppedSeeds: Math.max(0, ranked.length - kept.length),
+        scannedKeys: sweep.scanned,
+        scanBudgetExhausted: sweep.budgetExhausted,
+        query
+    };
+}

package/dist/core/triwiki/context-graph/query/snapshot-cache.js

@@ -0,0 +1,72 @@
+import path from 'node:path';
+import { shortDigest } from '../ids.js';
+export const CONTEXT_GRAPH_SNAPSHOT_CACHE_MAX_ENTRIES = 2;
+const entries = new Map();
+let hits = 0;
+let misses = 0;
+let evictions = 0;
+let clock = 0;
+export function contextGraphWorkspaceKey(root) {
+    return shortDigest(path.resolve(String(root ?? '')));
+}
+function cacheKey(workspaceKey, snapshotHash) {
+    return `${workspaceKey}:${snapshotHash}`;
+}
+export function getCachedContextGraphIndex(root, snapshotHash) {
+    if (!snapshotHash) {
+        misses += 1;
+        return null;
+    }
+    const key = cacheKey(contextGraphWorkspaceKey(root), snapshotHash);
+    const entry = entries.get(key);
+    if (!entry) {
+        misses += 1;
+        return null;
+    }
+    clock += 1;
+    entry.order = clock;
+    hits += 1;
+    return entry.index;
+}
+export function cacheContextGraphIndex(root, snapshotHash, index) {
+    if (!snapshotHash)
+        return;
+    const workspaceKey = contextGraphWorkspaceKey(root);
+    for (const [key, entry] of [...entries]) {
+        if (entry.workspaceKey === workspaceKey)
+            entries.delete(key);
+    }
+    clock += 1;
+    entries.set(cacheKey(workspaceKey, snapshotHash), { workspaceKey, snapshotHash, index, order: clock });
+    while (entries.size > CONTEXT_GRAPH_SNAPSHOT_CACHE_MAX_ENTRIES) {
+        let oldestKey = null;
+        let oldestOrder = Number.POSITIVE_INFINITY;
+        for (const [key, entry] of entries) {
+            if (entry.order < oldestOrder) {
+                oldestOrder = entry.order;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey === null)
+            break;
+        entries.delete(oldestKey);
+        evictions += 1;
+    }
+}
+export function clearContextGraphSnapshotCache() {
+    entries.clear();
+    hits = 0;
+    misses = 0;
+    evictions = 0;
+    clock = 0;
+}
+export function contextGraphSnapshotCacheStats() {
+    const lookups = hits + misses;
+    return {
+        entries: entries.size,
+        hits,
+        misses,
+        evictions,
+        hitRate: lookups === 0 ? 0 : hits / lookups
+    };
+}

package/dist/core/triwiki/context-graph/query/traverse.js

@@ -0,0 +1,154 @@
+import { incomingEdges, outgoingEdges } from '../graph-index.js';
+import { compareContextGraphIds, contextGraphPathFromId } from '../ids.js';
+import { profileEdgeWeight } from '../profiles.js';
+import { contextGraphSeedConfidenceScore } from './ranking-config.js';
+export function contextGraphNodePath(index, nodeId) {
+    const node = index.nodesById.get(nodeId);
+    if (node?.path)
+        return node.path;
+    return contextGraphPathFromId(nodeId);
+}
+export function isUnderFocusPath(nodePath, focusPaths) {
+    if (!nodePath)
+        return false;
+    for (const focus of focusPaths) {
+        if (!focus)
+            continue;
+        if (nodePath === focus || nodePath.startsWith(`${focus}/`))
+            return true;
+    }
+    return false;
+}
+function decayLadder(config, maxDepth) {
+    const ladder = [1];
+    for (let depth = 1; depth <= maxDepth; depth += 1) {
+        ladder.push((ladder[depth - 1] ?? 1) * config.depthDecay);
+    }
+    return ladder;
+}
+function neighbours(index, nodeId) {
+    const out = [];
+    for (const edge of outgoingEdges(index, nodeId))
+        out.push({ edge, neighbourId: edge.to, reverse: false });
+    for (const edge of incomingEdges(index, nodeId))
+        out.push({ edge, neighbourId: edge.from, reverse: true });
+    return out;
+}
+function improves(existing, depth, weight, edgeId) {
+    if (depth !== existing.depth)
+        return false;
+    if (weight !== existing.weight)
+        return weight > existing.weight;
+    if (existing.parentEdgeId === null)
+        return false;
+    return compareContextGraphIds(edgeId, existing.parentEdgeId) < 0;
+}
+export function traverseContextGraph(input) {
+    const { index, seeds, profile, maxDepth, maxVisitedNodes, maxVisitedEdges, config, focusPaths, deadline } = input;
+    const states = new Map();
+    const decay = decayLadder(config, maxDepth);
+    const focusActive = focusPaths.length > 0;
+    const queue = [];
+    for (const seed of seeds) {
+        if (!index.nodesById.has(seed.nodeId) || states.has(seed.nodeId))
+            continue;
+        if (states.size >= maxVisitedNodes)
+            break;
+        const path = contextGraphNodePath(index, seed.nodeId);
+        states.set(seed.nodeId, {
+            nodeId: seed.nodeId,
+            depth: 0,
+            weight: seed.score ?? contextGraphSeedConfidenceScore(config, seed.confidence),
+            seedNodeId: seed.nodeId,
+            parentNodeId: null,
+            parentEdgeId: null,
+            parentReverse: false,
+            focusMatched: !focusActive || isUnderFocusPath(path, focusPaths)
+        });
+        queue.push(seed.nodeId);
+    }
+    let visitedEdges = 0;
+    let depthLimited = 0;
+    let nodeCapHit = false;
+    let edgeCapHit = false;
+    let timedOut = false;
+    let sinceClockCheck = 0;
+    let head = 0;
+    while (head < queue.length) {
+        const nodeId = queue[head];
+        head += 1;
+        if (nodeId === undefined)
+            continue;
+        const state = states.get(nodeId);
+        if (!state)
+            continue;
+        if (state.depth >= maxDepth) {
+            depthLimited += 1;
+            continue;
+        }
+        const childDepth = state.depth + 1;
+        const childDecay = decay[childDepth] ?? 0;
+        for (const candidate of neighbours(index, nodeId)) {
+            if (visitedEdges >= maxVisitedEdges) {
+                edgeCapHit = true;
+                break;
+            }
+            visitedEdges += 1;
+            sinceClockCheck += 1;
+            if (sinceClockCheck >= config.timeoutCheckInterval) {
+                sinceClockCheck = 0;
+                if (deadline !== null && Date.now() > deadline) {
+                    timedOut = true;
+                    break;
+                }
+            }
+            const base = profileEdgeWeight(profile, candidate.edge.type);
+            if (base <= 0)
+                continue;
+            const neighbour = index.nodesById.get(candidate.neighbourId);
+            if (!neighbour)
+                continue;
+            const multiplier = config.edgeConfidenceMultiplier[candidate.edge.confidence] ?? 0;
+            const direction = candidate.reverse ? config.reverseEdgeMultiplier : 1;
+            const weight = state.weight * config.depthDecay + base * multiplier * direction * childDecay;
+            const existing = states.get(candidate.neighbourId);
+            if (existing) {
+                if (!improves(existing, childDepth, weight, candidate.edge.id))
+                    continue;
+                existing.weight = weight;
+                existing.seedNodeId = state.seedNodeId;
+                existing.parentNodeId = nodeId;
+                existing.parentEdgeId = candidate.edge.id;
+                existing.parentReverse = candidate.reverse;
+                existing.focusMatched = state.focusMatched || isUnderFocusPath(neighbour.path ?? contextGraphPathFromId(neighbour.id), focusPaths);
+                continue;
+            }
+            if (states.size >= maxVisitedNodes) {
+                nodeCapHit = true;
+                break;
+            }
+            states.set(candidate.neighbourId, {
+                nodeId: candidate.neighbourId,
+                depth: childDepth,
+                weight,
+                seedNodeId: state.seedNodeId,
+                parentNodeId: nodeId,
+                parentEdgeId: candidate.edge.id,
+                parentReverse: candidate.reverse,
+                focusMatched: state.focusMatched || isUnderFocusPath(neighbour.path ?? contextGraphPathFromId(neighbour.id), focusPaths)
+            });
+            queue.push(candidate.neighbourId);
+        }
+        if (timedOut || edgeCapHit || nodeCapHit)
+            break;
+    }
+    return {
+        states,
+        visitedNodes: states.size,
+        visitedEdges,
+        nodeCapHit,
+        edgeCapHit,
+        depthLimited,
+        timedOut
+    };
+}

package/dist/core/triwiki/context-graph/query-types.js

@@ -0,0 +1,29 @@
+export const CONTEXT_GRAPH_QUERY_SCHEMA = 'sks.context-graph-query.v1';
+export function emptyContextGraphQueryResult(snapshotHash, profile, errors = []) {
+    return {
+        schema: CONTEXT_GRAPH_QUERY_SCHEMA,
+        ok: errors.length === 0,
+        snapshotHash,
+        snapshotFreshness: 'stale',
+        profile,
+        seeds: [],
+        seedCount: 0,
+        visitedNodes: 0,
+        visitedEdges: 0,
+        selected: [],
+        selectedNodes: 0,
+        explanationPathCount: 0,
+        provenanceCoverage: 0,
+        staleExcluded: 0,
+        invalidatedExcluded: 0,
+        tokenCost: 0,
+        tokenBudget: 0,
+        truncated: false,
+        timeout: false,
+        omissionReasons: {},
+        warnings: [],
+        errors,
+        durationMs: 0,
+        processSpawns: 0
+    };
+}

package/dist/core/triwiki/context-graph/store/compile-lock.js

@@ -0,0 +1,21 @@
+import { tryWithFileLock } from '../../../locks/file-lock.js';
+import { contextGraphLockPath } from '../paths.js';
+export const CONTEXT_GRAPH_LOCK_STALE_MS = 120_000;
+function holderOf(owner) {
+    if (!owner || typeof owner.pid !== 'number')
+        return null;
+    return {
+        pid: owner.pid,
+        acquiredAt: String(owner.acquired_at ?? ''),
+        heartbeatAt: String(owner.heartbeat_at ?? '')
+    };
+}
+export async function withContextGraphCompileLock(root, fn, options = {}) {
+    const result = await tryWithFileLock({
+        lockPath: contextGraphLockPath(root),
+        staleMs: Math.max(1, options.staleMs ?? CONTEXT_GRAPH_LOCK_STALE_MS)
+    }, async () => fn());
+    if (!result.acquired)
+        return { acquired: false, recovered: false, holder: holderOf(result.owner) };
+    return { acquired: true, recovered: result.recovered, value: result.value };
+}

package/dist/core/triwiki/context-graph/store/event-log.js

@@ -0,0 +1,48 @@
+import { appendJsonlBounded } from '../../../fsx.js';
+import { contextGraphEventLogPath } from '../paths.js';
+export const CONTEXT_GRAPH_EVENT_SCHEMA = 'sks.context-graph-event.v1';
+export const CONTEXT_GRAPH_EVENT_LOG_MAX_BYTES = 2 * 1024 * 1024;
+export const CONTEXT_GRAPH_EVENT_TYPES = [
+    'compile.started',
+    'compile.committed',
+    'compile.blocked',
+    'compile.lock_contended',
+    'compile.unchanged',
+    'snapshot.corrupt',
+    'snapshot.missing'
+];
+function code(value) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim().slice(0, 64);
+    return /^[A-Za-z0-9_.:-]+$/.test(trimmed) ? trimmed : 'unspecified';
+}
+export function buildContextGraphEvent(input) {
+    const reason = code(input.reason);
+    return {
+        schema: CONTEXT_GRAPH_EVENT_SCHEMA,
+        ts: input.at,
+        type: input.type,
+        ...(input.cacheKey === undefined ? {} : { cache_key: input.cacheKey }),
+        ...(input.snapshotHash === undefined ? {} : { snapshot_hash: input.snapshotHash }),
+        ...(input.previousSnapshotHash === undefined
+            ? {}
+            : { previous_snapshot_hash: input.previousSnapshotHash }),
+        ...(input.nodeCount === undefined ? {} : { node_count: input.nodeCount }),
+        ...(input.edgeCount === undefined ? {} : { edge_count: input.edgeCount }),
+        ...(input.errorCount === undefined ? {} : { error_count: input.errorCount }),
+        ...(input.warningCount === undefined ? {} : { warning_count: input.warningCount }),
+        ...(input.durationMs === undefined ? {} : { duration_ms: input.durationMs }),
+        ...(reason === undefined ? {} : { reason }),
+        ...(input.incremental === undefined ? {} : { incremental: input.incremental })
+    };
+}
+export async function appendContextGraphEvent(root, input) {
+    try {
+        await appendJsonlBounded(contextGraphEventLogPath(root), buildContextGraphEvent(input), CONTEXT_GRAPH_EVENT_LOG_MAX_BYTES);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/triwiki/context-graph/store/fragment-cache.js

@@ -0,0 +1,85 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, sha256, writeJsonAtomic } from '../../../fsx.js';
+import { CONTEXT_GRAPH_FRAGMENT_SCHEMA } from '../contracts.js';
+import { contextGraphFragmentCacheDir } from '../paths.js';
+export const CONTEXT_GRAPH_FRAGMENT_CACHE_MAX_ENTRIES = 64;
+export function fragmentCacheKey(input) {
+    return sha256(JSON.stringify([
+        CONTEXT_GRAPH_FRAGMENT_SCHEMA,
+        input.extractorId,
+        input.extractorRevision,
+        input.cacheKey,
+        input.changedPaths === null ? null : [...input.changedPaths].sort()
+    ]));
+}
+function entryPath(root, key) {
+    return path.join(contextGraphFragmentCacheDir(root), `${key}.json`);
+}
+function isFragment(value, extractorId) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const fragment = value;
+    return (fragment.schema === CONTEXT_GRAPH_FRAGMENT_SCHEMA
+        && fragment.extractor === extractorId
+        && Array.isArray(fragment.nodes)
+        && Array.isArray(fragment.edges)
+        && Array.isArray(fragment.issues)
+        && Array.isArray(fragment.skipped)
+        && Boolean(fragment.inputHashes)
+        && typeof fragment.inputHashes === 'object');
+}
+export async function readCachedFragment(root, key, extractorId) {
+    let raw;
+    try {
+        raw = await fsp.readFile(entryPath(root, key), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return isFragment(parsed, extractorId) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCachedFragment(root, key, fragment) {
+    await ensureDir(contextGraphFragmentCacheDir(root));
+    await writeJsonAtomic(entryPath(root, key), fragment);
+}
+export async function pruneFragmentCache(root, maxEntries = CONTEXT_GRAPH_FRAGMENT_CACHE_MAX_ENTRIES) {
+    const dir = contextGraphFragmentCacheDir(root);
+    let names;
+    try {
+        names = (await fsp.readdir(dir)).filter((name) => name.endsWith('.json'));
+    }
+    catch {
+        return 0;
+    }
+    if (names.length <= maxEntries)
+        return 0;
+    const rows = [];
+    for (const name of names) {
+        const file = path.join(dir, name);
+        try {
+            const stat = await fsp.stat(file);
+            rows.push({ file, mtimeMs: stat.mtimeMs });
+        }
+        catch {
+        }
+    }
+    rows.sort((left, right) => right.mtimeMs - left.mtimeMs || (left.file < right.file ? -1 : 1));
+    const removable = rows.slice(maxEntries);
+    let removed = 0;
+    for (const row of removable) {
+        try {
+            await fsp.rm(row.file, { force: true });
+            removed += 1;
+        }
+        catch {
+        }
+    }
+    return removed;
+}