fix(cache): repair discovery globs, error discrimination, cache-dir linking, manifest refcounts, and LRU adapter defects

src/modules/react-loader/ssr-module-loader/loader.test.ts

@@ -27,6 +27,7 @@ import {
   buildMdxEsmPathCacheKey,
 } from "#veryfront/transforms/mdx/esm-module-loader/cache-format.ts";
 import type { RuntimeAdapter } from "#veryfront/platform/adapters/base.ts";
+import type { FileSystem } from "#veryfront/platform/compat/fs.ts";
 import type { ModuleCacheEntry } from "./types.ts";
 import {
   clearModulePathCache,
@@ -378,6 +379,65 @@ describe("SSRModuleLoader", { sanitizeResources: false, sanitizeOps: false }, ()
     }
   });
 
+  it("invalidates stale cache indexes when cached output cannot be inspected", async () => {
+    clearSSRModuleCache();
+
+    const projectDir = await makeTempDir({ prefix: "vf-ssr-loader-unreadable-output-" });
+    const filePath = join(projectDir, "UnreadableCachedOutput.tsx");
+    const projectId = "project-unreadable-cached-output-test";
+    const contentSourceId = "preview-main";
+    const source = "export default function UnreadableCachedOutput() { return null; }";
+    const contentHash = hashAsLoader(source, filePath, projectDir);
+    const configHash = computeConfigHashSync({ dev: true });
+    const reactVersion = "default";
+    const filePathCacheKey = buildSSRModuleCacheKey(
+      RUNTIME_VERSION,
+      projectId,
+      `${contentSourceId}:${reactVersion}:${configHash}:${filePath}`,
+    );
+    const contentCacheKey = buildSSRModuleCacheKey(
+      RUNTIME_VERSION,
+      projectId,
+      `${contentSourceId}:${reactVersion}:${configHash}:${filePath}:${contentHash}`,
+    );
+    const staleEntry = {
+      tempPath: join(projectDir, "unreadable-cache-output.mjs"),
+      contentHash,
+    };
+    globalModuleCache.set(contentCacheKey, staleEntry);
+    globalModuleCache.set(filePathCacheKey, staleEntry);
+    verifiedHttpBundlePaths.set(`${staleEntry.tempPath}:${contentHash}`, true);
+
+    const loader = new SSRModuleLoader({
+      projectDir,
+      projectId,
+      contentSourceId,
+      adapter: denoAdapter,
+      dev: true,
+    });
+    const cacheManager = (loader as unknown as {
+      cache: { fs: FileSystem; getFs(): FileSystem };
+    }).cache;
+    const originalFs = cacheManager.getFs();
+    cacheManager.fs = {
+      stat: () => Promise.reject(Object.assign(new Error("permission denied"), { code: "EACCES" })),
+    } as unknown as FileSystem;
+
+    try {
+      await assertRejects(
+        () => loader.loadModule(filePath, source),
+        Error,
+        "permission denied",
+      );
+      assertEquals(globalModuleCache.get(contentCacheKey), undefined);
+      assertEquals(globalModuleCache.get(filePathCacheKey), undefined);
+      assertEquals(verifiedHttpBundlePaths.get(`${staleEntry.tempPath}:${contentHash}`), undefined);
+    } finally {
+      cacheManager.fs = originalFs;
+      await remove(projectDir, { recursive: true });
+    }
+  });
+
   it("clears verified MDX-ESM path cache before retrying stale local dependencies", async () => {
     clearSSRModuleCache();
     clearModulePathCache();

src/modules/react-loader/ssr-module-loader/loader.ts

@@ -251,11 +251,21 @@ export class SSRModuleLoader {
     cacheEntry: ModuleCacheEntry,
   ): Promise<Record<string, unknown>> {
     // Verify the cache file exists before attempting dynamic import
-    const fileExists = await verifyCacheFileExists(
-      this.cache.getFs(),
-      cacheEntry.tempPath,
-      "SSR-MODULE-LOADER",
-    );
+    let fileExists: boolean;
+    try {
+      fileExists = await verifyCacheFileExists(
+        this.cache.getFs(),
+        cacheEntry.tempPath,
+        "SSR-MODULE-LOADER",
+      );
+    } catch (error) {
+      // An unreadable cache entry cannot be trusted on a later attempt. Keep
+      // the original operational error, but remove both indexes so a repaired
+      // filesystem does not keep routing requests back to stale metadata.
+      await this.invalidateMdxEsmCacheEntry(filePath, cacheEntry);
+      this.cache.invalidateFilePathCacheEntry(filePath, cacheEntry);
+      throw error;
+    }
     if (!fileExists) {
       logger.debug("Cache file missing before import, invalidating", {
         file: filePath.slice(-40),