@unbrained/pm-cli 2026.7.1 → 2026.7.3

package/dist/core/store/front-matter-cache.js

@@ -4,13 +4,14 @@
  * Reads and writes tracker storage with format-aware helpers for Front Matter Cache.
  */
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="5082ed3d-d631-51ec-97b6-af2817191f98")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="33a7cae0-25bf-5973-afc6-7666b14bf957")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { getActiveExtensionRegistrations, hasActiveOnReadHooks, runActiveOnReadHooks } from "../extensions/index.js";
 import { collectRegisteredItemFieldNames } from "../extensions/item-fields.js";
 import { parseItemDocument } from "../item/item-format.js";
+import { evictOldestMemoEntries } from "../shared/memo.js";
 import { writeFileAtomic } from "../fs/fs-utils.js";
 import { ITEM_FILE_EXTENSIONS, getItemFormatFromPath } from "./paths.js";
 const CACHE_VERSION = 6;
@@ -89,48 +90,106 @@ function getBodyCachePath(pmRoot) {
 function getCollectionsCachePath(pmRoot) {
     return path.join(pmRoot, "runtime", COLLECTIONS_CACHE_FILENAME);
 }
-async function loadCache(pmRoot) {
+/**
+ * In-process memo of parsed cache envelopes keyed by cache file path and validated
+ * against the file's stat signature on every load. Commands that scan the corpus more
+ * than once per invocation (`pm next`, `pm context`) and long-lived in-process hosts
+ * (the MCP server) would otherwise re-read and re-parse multi-megabyte JSON on every
+ * scan. Envelopes handed out from the memo are shared, so they must be treated as
+ * read-only — the write path always goes through `mutateItem` on a `structuredClone`d
+ * document parsed fresh from the item file, never through listed cache metadata.
+ *
+ * The cap bounds memory when one long-lived process serves many project roots
+ * (3 envelopes per root). Hits re-insert their entry so Map insertion order tracks
+ * recency, making the half-eviction drop the least-recently-used roots.
+ */
+const ENVELOPE_MEMO_MAX_ENTRIES = 24;
+const envelopeMemo = new Map();
+function memoizeEnvelope(cachePath, entry) {
+    if (envelopeMemo.size >= ENVELOPE_MEMO_MAX_ENTRIES && !envelopeMemo.has(cachePath)) {
+        evictOldestMemoEntries(envelopeMemo);
+    }
+    envelopeMemo.set(cachePath, entry);
+}
+async function loadEnvelopeMemoized(cachePath, parse) {
+    let stat;
+    try {
+        stat = await fs.stat(cachePath);
+    }
+    catch {
+        envelopeMemo.delete(cachePath);
+        return null;
+    }
+    const memoized = envelopeMemo.get(cachePath);
+    if (memoized && statMatches(memoized.signature, stat.mtimeMs, stat.ctimeMs, stat.size)) {
+        // Re-insert on hit so insertion order tracks recency for the LRU half-eviction.
+        envelopeMemo.delete(cachePath);
+        envelopeMemo.set(cachePath, memoized);
+        return memoized.envelope;
+    }
+    let envelope;
     try {
-        const raw = await fs.readFile(getCachePath(pmRoot), "utf8");
+        envelope = parse(await fs.readFile(cachePath, "utf8"));
+    }
+    catch {
+        envelope = null;
+    }
+    memoizeEnvelope(cachePath, {
+        signature: { mtime_ms: stat.mtimeMs, ctime_ms: stat.ctimeMs, size: stat.size },
+        envelope,
+    });
+    return envelope;
+}
+/**
+ * Drop memoized envelopes. Exposed for tests; production invalidation is stat-driven
+ * plus the explicit delete in {@link persistCache} after a rewrite.
+ */
+export function clearFrontMatterEnvelopeMemo() {
+    envelopeMemo.clear();
+}
+async function loadCache(pmRoot) {
+    return await loadEnvelopeMemoized(getCachePath(pmRoot), (raw) => {
         const parsed = JSON.parse(raw);
         if (parsed.version !== CACHE_VERSION || typeof parsed.entries !== "object" || parsed.entries === null) {
             return null;
         }
         return parsed;
-    }
-    catch {
-        return null;
-    }
+    });
 }
 async function loadBodyCache(pmRoot) {
-    try {
-        const raw = await fs.readFile(getBodyCachePath(pmRoot), "utf8");
+    return await loadEnvelopeMemoized(getBodyCachePath(pmRoot), (raw) => {
         const parsed = JSON.parse(raw);
         if (parsed.version !== CACHE_VERSION || typeof parsed.bodies !== "object" || parsed.bodies === null) {
             return null;
         }
         return parsed;
-    }
-    catch {
-        return null;
-    }
+    });
 }
 async function loadCollectionsCache(pmRoot) {
-    try {
-        const raw = await fs.readFile(getCollectionsCachePath(pmRoot), "utf8");
+    return await loadEnvelopeMemoized(getCollectionsCachePath(pmRoot), (raw) => {
         const parsed = JSON.parse(raw);
         if (parsed.version !== CACHE_VERSION || typeof parsed.collections !== "object" || parsed.collections === null) {
             return null;
         }
         return parsed;
-    }
-    catch {
-        return null;
-    }
+    });
 }
 async function persistCache(cachePath, envelope) {
     await fs.mkdir(path.dirname(cachePath), { recursive: true });
     await writeFileAtomic(cachePath, JSON.stringify(envelope));
+    // Repopulate the memo with the just-written envelope so the next read after a
+    // write skips the cold re-read; fall back to plain invalidation when the fresh
+    // stat signature cannot be captured.
+    try {
+        const stat = await fs.stat(cachePath);
+        memoizeEnvelope(cachePath, {
+            signature: { mtime_ms: stat.mtimeMs, ctime_ms: stat.ctimeMs, size: stat.size },
+            envelope,
+        });
+    }
+    catch {
+        envelopeMemo.delete(cachePath);
+    }
 }
 /**
  * Decide whether a freshly parsed document candidate should replace the one
@@ -158,6 +217,219 @@ function appendWarning(warnings, warning) {
 function statMatches(signature, mtimeMs, ctimeMs, size) {
     return signature.mtime_ms === mtimeMs && signature.ctime_ms === ctimeMs && signature.size === size;
 }
+async function readItemDirectoryFiles(pmRoot, folder, warnings) {
+    const dirPath = path.join(pmRoot, folder);
+    try {
+        const files = await fs.readdir(dirPath);
+        return { folder, dirPath, files };
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code !== "ENOENT") {
+            appendWarning(warnings, `item_list_directory_read_failed:${folder}`);
+        }
+        return { folder, dirPath, files: [] };
+    }
+}
+function isItemDocumentFile(file) {
+    return ITEM_FILE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext));
+}
+function markDocumentCacheMisses(misses, includeBody, includeCollections, metadataCached, bodyCached, collectionsCached) {
+    if (!metadataCached) {
+        misses.metadata = true;
+    }
+    if (includeBody && !bodyCached) {
+        misses.body = true;
+    }
+    if (includeCollections && !collectionsCached) {
+        misses.collections = true;
+    }
+}
+async function dispatchCachedDocumentReadHooks(filePath, warnings, dispatchReadHooks) {
+    if (!dispatchReadHooks) {
+        return;
+    }
+    for (const warning of await runActiveOnReadHooks({ path: filePath, scope: "project" })) {
+        appendWarning(warnings, warning);
+    }
+}
+async function readCachedDocumentParts(filePath, relativePath, context) {
+    const stat = await fs.stat(filePath);
+    const mtimeMs = stat.mtimeMs;
+    const ctimeMs = stat.ctimeMs;
+    const { size } = stat;
+    const itemFormat = getItemFormatFromPath(filePath);
+    await dispatchCachedDocumentReadHooks(filePath, context.warnings, context.dispatchReadHooks);
+    const cachedEntry = context.previousEntries[relativePath];
+    const metadataCached = cachedEntry !== undefined && statMatches(cachedEntry, mtimeMs, ctimeMs, size);
+    const cachedBody = context.previousBodies[relativePath];
+    const bodyCached = cachedBody !== undefined && statMatches(cachedBody, mtimeMs, ctimeMs, size);
+    const cachedCollections = context.previousCollections[relativePath];
+    const collectionsCached = cachedCollections !== undefined && statMatches(cachedCollections, mtimeMs, ctimeMs, size);
+    const needRead = !metadataCached || (context.includeBody && !bodyCached) || (context.includeCollections && !collectionsCached);
+    if (!needRead) {
+        return {
+            mtimeMs,
+            ctimeMs,
+            size,
+            itemFormat,
+            lightMetadata: cachedEntry.metadata,
+            heavyMetadata: context.includeCollections && cachedCollections ? cachedCollections.collections : undefined,
+            bodyLength: cachedEntry.body_length,
+            body: context.includeBody ? cachedBody.body : undefined,
+        };
+    }
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = parseItemDocument(raw, {
+        format: itemFormat,
+        schema: context.schema,
+        extensionFieldNames: context.extensionFieldNames,
+        onWarning: (warning) => appendWarning(context.warnings, warning),
+    });
+    const split = splitHeavyMetadata(parsed.metadata);
+    markDocumentCacheMisses(context.state.misses, context.includeBody, context.includeCollections, metadataCached, bodyCached, collectionsCached);
+    return {
+        mtimeMs,
+        ctimeMs,
+        size,
+        itemFormat,
+        lightMetadata: metadataCached ? cachedEntry.metadata : split.light,
+        heavyMetadata: context.includeCollections
+            ? collectionsCached
+                ? cachedCollections.collections
+                : split.heavy
+            : undefined,
+        bodyLength: metadataCached ? cachedEntry.body_length : parsed.body.length,
+        body: context.includeBody ? parsed.body : undefined,
+    };
+}
+function recordCachedDocumentCandidate(filePath, relativePath, context, parts) {
+    context.state.newEntries[relativePath] = {
+        mtime_ms: parts.mtimeMs,
+        ctime_ms: parts.ctimeMs,
+        size: parts.size,
+        metadata: parts.lightMetadata,
+        body_length: parts.bodyLength,
+    };
+    if (context.includeBody && parts.body !== undefined) {
+        context.state.newBodies[relativePath] = {
+            mtime_ms: parts.mtimeMs,
+            ctime_ms: parts.ctimeMs,
+            size: parts.size,
+            body: parts.body,
+        };
+    }
+    if (context.includeCollections && parts.heavyMetadata !== undefined) {
+        context.state.newCollections[relativePath] = {
+            mtime_ms: parts.mtimeMs,
+            ctime_ms: parts.ctimeMs,
+            size: parts.size,
+            collections: parts.heavyMetadata,
+        };
+    }
+    const metadata = context.includeCollections ? mergeHeavyMetadata(parts.lightMetadata, parts.heavyMetadata) : parts.lightMetadata;
+    const existing = context.state.documentsById.get(metadata.id);
+    const candidate = {
+        metadata,
+        body: parts.body,
+        item_format: parts.itemFormat,
+        item_path: filePath,
+    };
+    if (!existing || shouldReplaceCachedDocumentCandidate(existing.itemFormat, parts.itemFormat, context.preferredFormat)) {
+        context.state.documentsById.set(metadata.id, { candidate, itemFormat: parts.itemFormat });
+    }
+}
+async function processCachedDocumentFile(folder, filePath, relativePath, context) {
+    try {
+        const parts = await readCachedDocumentParts(filePath, relativePath, context);
+        recordCachedDocumentCandidate(filePath, relativePath, context, parts);
+    }
+    catch {
+        appendWarning(context.warnings, `item_list_item_read_failed:${folder}/${path.basename(filePath)}`);
+    }
+}
+function selectPreviousMetadataEntries(existingCache, contextFingerprint) {
+    return existingCache && existingCache.context_fingerprint === contextFingerprint ? existingCache.entries : {};
+}
+function selectPreviousBodyEntries(existingBodyCache, contextFingerprint) {
+    return existingBodyCache && existingBodyCache.context_fingerprint === contextFingerprint ? existingBodyCache.bodies : {};
+}
+function selectPreviousCollectionEntries(existingCollectionsCache, contextFingerprint) {
+    return existingCollectionsCache && existingCollectionsCache.context_fingerprint === contextFingerprint
+        ? existingCollectionsCache.collections
+        : {};
+}
+function createDocumentCacheMutableState() {
+    return {
+        newEntries: {},
+        newBodies: {},
+        newCollections: {},
+        documentsById: new Map(),
+        misses: {
+            metadata: false,
+            body: false,
+            collections: false,
+        },
+    };
+}
+function collectCachedDocumentParseTasks(dirResults, context) {
+    const parseTasks = [];
+    for (const { folder, dirPath, files } of dirResults) {
+        for (const file of files) {
+            if (!isItemDocumentFile(file)) {
+                continue;
+            }
+            const filePath = path.join(dirPath, file);
+            const relativePath = path.relative(context.pmRoot, filePath);
+            parseTasks.push(processCachedDocumentFile(folder, filePath, relativePath, context));
+        }
+    }
+    return parseTasks;
+}
+async function persistMetadataCacheIfNeeded(params) {
+    const metadataDirty = params.state.misses.metadata ||
+        Object.keys(params.previousEntries).length !== Object.keys(params.state.newEntries).length;
+    if (!metadataDirty && params.existingCache !== null && params.existingCache.context_fingerprint === params.contextFingerprint) {
+        return;
+    }
+    await persistCache(getCachePath(params.pmRoot), {
+        version: CACHE_VERSION,
+        context_fingerprint: params.contextFingerprint,
+        entries: params.state.newEntries,
+    }).catch(() => { });
+}
+async function persistBodyCacheIfNeeded(params) {
+    const bodyDirty = params.state.misses.body ||
+        Object.keys(params.previousBodies).length !== Object.keys(params.state.newBodies).length;
+    if (!bodyDirty &&
+        params.existingBodyCache !== null &&
+        params.existingBodyCache.context_fingerprint === params.contextFingerprint) {
+        return;
+    }
+    await persistCache(getBodyCachePath(params.pmRoot), {
+        version: CACHE_VERSION,
+        context_fingerprint: params.contextFingerprint,
+        bodies: params.state.newBodies,
+    }).catch(() => { });
+}
+async function persistCollectionsCacheIfNeeded(params) {
+    const collectionsDirty = params.state.misses.collections ||
+        Object.keys(params.previousCollections).length !== Object.keys(params.state.newCollections).length;
+    if (!collectionsDirty &&
+        params.existingCollectionsCache !== null &&
+        params.existingCollectionsCache.context_fingerprint === params.contextFingerprint) {
+        return;
+    }
+    await persistCache(getCollectionsCachePath(params.pmRoot), {
+        version: CACHE_VERSION,
+        context_fingerprint: params.contextFingerprint,
+        collections: params.state.newCollections,
+    }).catch(() => { });
+}
+function sortedCachedDocumentCandidates(state) {
+    return [...state.documentsById.values()]
+        .sort((left, right) => left.candidate.metadata.id.localeCompare(right.candidate.metadata.id))
+        .map((entry) => entry.candidate);
+}
 /**
  * List all item documents using a persistent on-disk metadata cache.
  *
@@ -174,167 +446,40 @@ export async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, t
     const extensionFieldNames = resolveActiveExtensionFieldNames();
     const contextFingerprint = computeContextFingerprint(preferredFormat, typeToFolder, schema, extensionFieldNames);
     const existingCache = await loadCache(pmRoot);
-    const previousEntries = existingCache && existingCache.context_fingerprint === contextFingerprint ? existingCache.entries : {};
+    const previousEntries = selectPreviousMetadataEntries(existingCache, contextFingerprint);
     const existingBodyCache = includeBody ? await loadBodyCache(pmRoot) : null;
-    const previousBodies = existingBodyCache && existingBodyCache.context_fingerprint === contextFingerprint ? existingBodyCache.bodies : {};
+    const previousBodies = selectPreviousBodyEntries(existingBodyCache, contextFingerprint);
     const existingCollectionsCache = includeCollections ? await loadCollectionsCache(pmRoot) : null;
-    const previousCollections = existingCollectionsCache && existingCollectionsCache.context_fingerprint === contextFingerprint
-        ? existingCollectionsCache.collections
-        : {};
+    const previousCollections = selectPreviousCollectionEntries(existingCollectionsCache, contextFingerprint);
     const entries = Object.entries(typeToFolder);
-    const dirResults = await Promise.all(entries.map(async ([, folder]) => {
-        const dirPath = path.join(pmRoot, folder);
-        try {
-            const files = await fs.readdir(dirPath);
-            return { folder, dirPath, files };
-        }
-        catch (error) {
-            if (typeof error === "object" && error !== null && "code" in error && error.code !== "ENOENT") {
-                appendWarning(warnings, `item_list_directory_read_failed:${folder}`);
-            }
-            return { folder, dirPath, files: [] };
-        }
-    }));
+    const dirResults = await Promise.all(entries.map(([, folder]) => readItemDirectoryFiles(pmRoot, folder, warnings)));
     const dispatchReadHooks = hasActiveOnReadHooks();
-    const newEntries = {};
-    const newBodies = {};
-    const newCollections = {};
-    const documentsById = new Map();
-    let metadataMiss = false;
-    let bodyMiss = false;
-    let collectionsMiss = false;
-    const parseTasks = [];
-    for (const { folder, dirPath, files } of dirResults) {
-        for (const file of files) {
-            if (!ITEM_FILE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext))) {
-                continue;
-            }
-            const filePath = path.join(dirPath, file);
-            const relativePath = path.relative(pmRoot, filePath);
-            parseTasks.push((async () => {
-                try {
-                    const stat = await fs.stat(filePath);
-                    const mtimeMs = stat.mtimeMs;
-                    const ctimeMs = stat.ctimeMs;
-                    const { size } = stat;
-                    const itemFormat = getItemFormatFromPath(filePath);
-                    // Preserve onRead hook semantics even when served from cache, but only
-                    // when an extension actually observes reads. Surface hook warnings so
-                    // read-hook failures are not silently hidden.
-                    if (dispatchReadHooks) {
-                        for (const warning of await runActiveOnReadHooks({ path: filePath, scope: "project" })) {
-                            appendWarning(warnings, warning);
-                        }
-                    }
-                    const cachedEntry = previousEntries[relativePath];
-                    const metadataCached = cachedEntry !== undefined && statMatches(cachedEntry, mtimeMs, ctimeMs, size);
-                    const cachedBody = previousBodies[relativePath];
-                    const bodyCached = cachedBody !== undefined && statMatches(cachedBody, mtimeMs, ctimeMs, size);
-                    const cachedCollections = previousCollections[relativePath];
-                    const collectionsCached = cachedCollections !== undefined && statMatches(cachedCollections, mtimeMs, ctimeMs, size);
-                    const needRead = !metadataCached || (includeBody && !bodyCached) || (includeCollections && !collectionsCached);
-                    let lightMetadata;
-                    let heavyMetadata;
-                    let bodyLength;
-                    let body;
-                    if (needRead) {
-                        const raw = await fs.readFile(filePath, "utf8");
-                        const parsed = parseItemDocument(raw, {
-                            format: itemFormat,
-                            schema,
-                            extensionFieldNames,
-                            onWarning: (w) => appendWarning(warnings, w),
-                        });
-                        const split = splitHeavyMetadata(parsed.metadata);
-                        lightMetadata = metadataCached ? cachedEntry.metadata : split.light;
-                        bodyLength = metadataCached ? cachedEntry.body_length : parsed.body.length;
-                        body = includeBody ? parsed.body : undefined;
-                        if (includeCollections) {
-                            heavyMetadata = collectionsCached ? cachedCollections.collections : split.heavy;
-                        }
-                        if (!metadataCached) {
-                            metadataMiss = true;
-                        }
-                        if (includeBody && !bodyCached) {
-                            bodyMiss = true;
-                        }
-                        if (includeCollections && !collectionsCached) {
-                            collectionsMiss = true;
-                        }
-                    }
-                    else {
-                        lightMetadata = cachedEntry.metadata;
-                        bodyLength = cachedEntry.body_length;
-                        body = includeBody ? cachedBody.body : undefined;
-                        heavyMetadata = includeCollections && cachedCollections ? cachedCollections.collections : undefined;
-                    }
-                    newEntries[relativePath] = {
-                        mtime_ms: mtimeMs,
-                        ctime_ms: ctimeMs,
-                        size,
-                        metadata: lightMetadata,
-                        body_length: bodyLength,
-                    };
-                    if (includeBody && body !== undefined) {
-                        newBodies[relativePath] = { mtime_ms: mtimeMs, ctime_ms: ctimeMs, size, body };
-                    }
-                    if (includeCollections && heavyMetadata !== undefined) {
-                        newCollections[relativePath] = { mtime_ms: mtimeMs, ctime_ms: ctimeMs, size, collections: heavyMetadata };
-                    }
-                    const metadata = includeCollections ? mergeHeavyMetadata(lightMetadata, heavyMetadata) : lightMetadata;
-                    const existing = documentsById.get(metadata.id);
-                    const candidate = {
-                        metadata,
-                        body,
-                        item_format: itemFormat,
-                        item_path: filePath,
-                    };
-                    if (!existing || shouldReplaceCachedDocumentCandidate(existing.itemFormat, itemFormat, preferredFormat)) {
-                        documentsById.set(metadata.id, { candidate, itemFormat });
-                    }
-                }
-                catch {
-                    appendWarning(warnings, `item_list_item_read_failed:${folder}/${file}`);
-                }
-            })());
-        }
-    }
-    await Promise.all(parseTasks);
+    const state = createDocumentCacheMutableState();
+    const context = {
+        pmRoot,
+        preferredFormat,
+        warnings,
+        schema,
+        extensionFieldNames,
+        includeBody,
+        includeCollections,
+        dispatchReadHooks,
+        previousEntries,
+        previousBodies,
+        previousCollections,
+        state,
+    };
+    await Promise.all(collectCachedDocumentParseTasks(dirResults, context));
     // Rewrite a cache file only when its contents changed: any re-parsed (missing or
     // stale) entry, or a different set of keys (additions/deletions).
-    const metadataDirty = metadataMiss || Object.keys(previousEntries).length !== Object.keys(newEntries).length;
-    if (metadataDirty || existingCache === null || existingCache.context_fingerprint !== contextFingerprint) {
-        await persistCache(getCachePath(pmRoot), {
-            version: CACHE_VERSION,
-            context_fingerprint: contextFingerprint,
-            entries: newEntries,
-        }).catch(() => { });
-    }
+    await persistMetadataCacheIfNeeded({ pmRoot, contextFingerprint, existingCache, previousEntries, state });
     if (includeBody) {
-        const bodyDirty = bodyMiss || Object.keys(previousBodies).length !== Object.keys(newBodies).length;
-        if (bodyDirty || existingBodyCache === null || existingBodyCache.context_fingerprint !== contextFingerprint) {
-            await persistCache(getBodyCachePath(pmRoot), {
-                version: CACHE_VERSION,
-                context_fingerprint: contextFingerprint,
-                bodies: newBodies,
-            }).catch(() => { });
-        }
+        await persistBodyCacheIfNeeded({ pmRoot, contextFingerprint, existingBodyCache, previousBodies, state });
     }
     if (includeCollections) {
-        const collectionsDirty = collectionsMiss || Object.keys(previousCollections).length !== Object.keys(newCollections).length;
-        if (collectionsDirty ||
-            existingCollectionsCache === null ||
-            existingCollectionsCache.context_fingerprint !== contextFingerprint) {
-            await persistCache(getCollectionsCachePath(pmRoot), {
-                version: CACHE_VERSION,
-                context_fingerprint: contextFingerprint,
-                collections: newCollections,
-            }).catch(() => { });
-        }
+        await persistCollectionsCacheIfNeeded({ pmRoot, contextFingerprint, existingCollectionsCache, previousCollections, state });
     }
-    return [...documentsById.values()]
-        .sort((left, right) => left.candidate.metadata.id.localeCompare(right.candidate.metadata.id))
-        .map((entry) => entry.candidate);
+    return sortedCachedDocumentCandidates(state);
 }
 /**
  * Implements list all documents cached for the public runtime surface of this module.
@@ -365,4 +510,4 @@ export async function listAllDocumentsCachedLight(pmRoot, preferredFormat, typeT
     }));
 }
 //# sourceMappingURL=front-matter-cache.js.map
-//# debugId=5082ed3d-d631-51ec-97b6-af2817191f98
+//# debugId=33a7cae0-25bf-5973-afc6-7666b14bf957