veryfront 0.0.81 → 0.0.83

package/src/src/platform/adapters/fs/cache/file-cache.ts

@@ -221,7 +221,9 @@ export class FileCache {
       const serialized = JSON.stringify(entry);
       // Update request-scoped cache so subsequent reads in same request see the new value
       setInRequestCache(key, serialized);
-      backend.set(key, serialized, BACKEND_TTL_SECONDS).catch(() => {});
+      backend.set(key, serialized, BACKEND_TTL_SECONDS).catch((error) => {
+        logger.debug("[FileCache] Backend set failed", { key, error });
+      });
       return;
     }
 
@@ -308,7 +310,9 @@ export class FileCache {
 
     // Fire-and-forget backend deletion
     // Note: prefix already includes "file:" from buildFileCacheKeyPrefix, don't add it again
-    cacheBackend?.delByPattern?.(`${prefix}*`).catch(() => {});
+    cacheBackend?.delByPattern?.(`${prefix}*`).catch((error) => {
+      logger.debug("[FileCache] Backend invalidation failed", { prefix, error });
+    });
 
     return count;
   }
@@ -346,7 +350,9 @@ export class FileCache {
 
     // Fire-and-forget backend deletion
     // Note: prefix already includes "file:" from buildFileCacheKeyPrefix, don't add it again
-    cacheBackend?.delByPattern?.(`${prefix}*:${suffix}`).catch(() => {});
+    cacheBackend?.delByPattern?.(`${prefix}*:${suffix}`).catch((error) => {
+      logger.debug("[FileCache] Backend invalidation failed", { prefix, suffix, error });
+    });
 
     return count;
   }

package/src/src/rendering/orchestrator/module-loader/cache.ts

@@ -1,4 +1,18 @@
+/**
+ * Module Loader Cache Utilities
+ *
+ * Provides hash generation and cache factory functions.
+ * Module caches are now pod-level singletons (see src/cache/module-cache.ts)
+ * to ensure caches persist across requests within the same pod.
+ *
+ * @module rendering/orchestrator/module-loader/cache
+ */
+
+// Re-export pod-level cache factories
 import * as dntShim from "../../../../_dnt.shims.js";
+
+export { createEsmCache, createModuleCache } from "../../../cache/module-cache.js";
+
 const HEX_CHARS = "0123456789abcdef";
 
 export async function generateHash(str: string): Promise<string> {
@@ -13,11 +27,3 @@ export async function generateHash(str: string): Promise<string> {
   }
   return hex;
 }
-
-export function createModuleCache(): Map<string, string> {
-  return new Map();
-}
-
-export function createEsmCache(): Map<string, string> {
-  return new Map();
-}

package/src/src/rendering/orchestrator/module-loader/index.ts

@@ -7,80 +7,52 @@
  */
 
 import { parallelMap, rendererLogger as logger } from "../../../utils/index.js";
-import { Singleflight } from "../../../utils/singleflight.js";
 import type { RuntimeAdapter } from "../../../platform/adapters/base.js";
-import type { CacheBackend } from "../../../cache/backend.js";
 import { getLocalAdapter } from "../../../platform/adapters/registry.js";
 import { generateHash } from "./cache.js";
 import { findLocalLibFile, findSourceFile } from "../file-resolver/index.js";
 import { transformToESM } from "../../../transforms/esm-transform.js";
 import { getProjectTmpDir } from "../../../modules/react-loader/index.js";
-import { TRANSFORM_CACHE_VERSION } from "../../../transforms/esm/package-registry.js";
+import {
+  generateCacheKey as generateTransformCacheKey,
+  getOrComputeTransform,
+  initializeTransformCache,
+  setCachedTransformAsync,
+} from "../../../transforms/esm/transform-cache.js";
+import { hashString } from "../../../cache/hash.js";
+import { TRANSFORM_DISTRIBUTED_TTL_SEC } from "../../../utils/constants/cache.js";
+import { ensureHttpBundlesExist } from "../../../transforms/esm/http-cache.js";
+import { getHttpBundleCacheDir } from "../../../utils/cache-dir.js";
 
 // Re-export utilities
 export { createEsmCache, createModuleCache, generateHash } from "./cache.js";
 export { fetchEsmModule, rewriteEsmPaths } from "./esm-rewriter.js";
 
-/** Cache for created directories to avoid repeated mkdir calls */
-const createdDirs = new Set<string>();
-
-/**
- * Distributed transform cache for cross-pod sharing.
- * Caches transformed module code in Redis/API so other pods don't need to re-transform.
- */
-let distributedTransformCache: CacheBackend | null | undefined;
-const distributedCacheInit = new Singleflight<CacheBackend | null>();
-
-/** TTL for cached transforms (24 hours) */
-const TRANSFORM_CACHE_TTL_SECONDS = 86400;
-
-function getDistributedTransformCache(): Promise<CacheBackend | null> {
-  if (distributedTransformCache !== undefined) {
-    return Promise.resolve(distributedTransformCache);
-  }
-
-  return distributedCacheInit.do("init", async () => {
-    try {
-      const { CacheBackends } = await import("../../../cache/backend.js");
-      const backend = await CacheBackends.transform();
-
-      // Only use distributed cache if API or Redis (not memory - that's per-process)
-      if (backend.type === "memory") {
-        distributedTransformCache = null;
-        logger.debug("[ModuleLoader] No distributed transform cache (memory only)");
-        return null;
-      }
-
-      distributedTransformCache = backend;
-      logger.debug("[ModuleLoader] Distributed transform cache initialized", {
-        type: backend.type,
-      });
-      return backend;
-    } catch (error) {
-      logger.debug("[ModuleLoader] Failed to init distributed transform cache", { error });
-      distributedTransformCache = null;
-      return null;
+/** Pattern to match HTTP bundle file:// paths in transformed code */
+const HTTP_BUNDLE_PATTERN = /file:\/\/([^"'\s]+veryfront-http-bundle\/http-([a-f0-9]+)\.mjs)/gi;
+
+/** Extract HTTP bundle paths from transformed code for proactive recovery */
+function extractHttpBundlePaths(code: string): Array<{ path: string; hash: string }> {
+  const bundles: Array<{ path: string; hash: string }> = [];
+  const seen = new Set<string>();
+  let match;
+  while ((match = HTTP_BUNDLE_PATTERN.exec(code)) !== null) {
+    const path = match[1] as string;
+    const hash = match[2] as string;
+    if (!seen.has(hash)) {
+      seen.add(hash);
+      bundles.push({ path, hash });
     }
-  });
+  }
+  HTTP_BUNDLE_PATTERN.lastIndex = 0;
+  return bundles;
 }
 
-/**
- * Build cache key for transformed module.
- * Includes content hash so cache invalidates when source changes.
- */
-function getTransformCacheKey(projectId: string, filePath: string, contentHash: string): string {
-  return `v${TRANSFORM_CACHE_VERSION}:${projectId}:${filePath}:${contentHash}`;
-}
+/** Cache for created directories to avoid repeated mkdir calls */
+const createdDirs = new Set<string>();
 
-/** Simple string hash for cache keys */
-function hashString(str: string): string {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    hash = ((hash << 5) - hash) + str.charCodeAt(i);
-    hash &= hash;
-  }
-  return Math.abs(hash).toString(36);
-}
+/** TTL for cached transforms (uses centralized config) */
+const TRANSFORM_CACHE_TTL_SECONDS = TRANSFORM_DISTRIBUTED_TTL_SEC;
 
 export interface ModuleLoaderConfig {
   projectDir: string;
@@ -223,39 +195,54 @@ export async function transformModuleWithDeps(
 
   const contentHash = hashString(fileContent);
   const effectiveProjectId = projectId ?? projectDir;
-  const transformCacheKey = getTransformCacheKey(effectiveProjectId, filePath, contentHash);
-
-  let transformedCode: string | null = null;
-  const distributedCache = await getDistributedTransformCache();
+  const scopedPath = `${effectiveProjectId}:${filePath}`;
+  const transformCacheKey = generateTransformCacheKey(scopedPath, contentHash, true); // ssr=true
+
+  // Initialize transform cache (lazy, only once per pod)
+  await initializeTransformCache();
+
+  // Use consolidated transform cache with getOrCompute pattern
+  let transformedCode = await getOrComputeTransform(
+    transformCacheKey,
+    () => {
+      logger.debug("[ModuleLoader] Transform cache miss, transforming", { filePath });
+      return transformToESM(fileContent, filePath, projectDir, adapter, {
+        projectId: effectiveProjectId,
+        dev: mode === "development",
+        ssr: true,
+      });
+    },
+    TRANSFORM_CACHE_TTL_SECONDS,
+  );
 
-  if (distributedCache) {
-    try {
-      const cached = await distributedCache.get(transformCacheKey);
-      if (cached) {
-        transformedCode = cached;
-        logger.debug("[ModuleLoader] Distributed transform cache HIT", {
+  // Proactively ensure HTTP bundles exist before writing the module.
+  // Cached transforms from a different pod may reference file:// paths
+  // to HTTP bundles that don't exist locally.
+  const bundlePaths = extractHttpBundlePaths(transformedCode);
+  if (bundlePaths.length > 0) {
+    const cacheDir = getHttpBundleCacheDir();
+    const failed = await ensureHttpBundlesExist(bundlePaths, cacheDir);
+    if (failed.length > 0) {
+      logger.warn("[ModuleLoader] HTTP bundle recovery failed, re-transforming", {
+        filePath,
+        failed,
+      });
+      transformedCode = await transformToESM(fileContent, filePath, projectDir, adapter, {
+        projectId: effectiveProjectId,
+        dev: mode === "development",
+        ssr: true,
+      });
+      setCachedTransformAsync(
+        transformCacheKey,
+        transformedCode,
+        contentHash,
+        TRANSFORM_CACHE_TTL_SECONDS,
+      ).catch((error) => {
+        logger.debug("[ModuleLoader] Failed to update transform cache after re-transform", {
           filePath,
-          cacheKey: transformCacheKey,
-        });
-      }
-    } catch (error) {
-      logger.debug("[ModuleLoader] Distributed cache get failed", { filePath, error });
-    }
-  }
-
-  if (!transformedCode) {
-    transformedCode = await transformToESM(fileContent, filePath, projectDir, adapter, {
-      projectId: effectiveProjectId,
-      dev: mode === "development",
-      ssr: true,
-    });
-
-    if (distributedCache) {
-      distributedCache
-        .set(transformCacheKey, transformedCode, TRANSFORM_CACHE_TTL_SECONDS)
-        .catch((error) => {
-          logger.debug("[ModuleLoader] Distributed cache set failed", { filePath, error });
+          error,
         });
+      });
     }
   }
 
@@ -296,6 +283,24 @@ export async function loadModule(filePath: string, config: ModuleLoaderConfig):
   try {
     return await import(moduleUrl);
   } catch (error) {
+    // If import fails due to missing HTTP bundle, try to recover and retry once
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const bundleMatch = errorMsg.match(/veryfront-http-bundle\/http-([a-f0-9]+)\.mjs/);
+    if (bundleMatch) {
+      const hash = bundleMatch[1]!;
+      logger.warn("[ModuleLoader] Import failed due to missing HTTP bundle, attempting recovery", {
+        filePath,
+        hash,
+      });
+      const { recoverHttpBundleByHash } = await import("../../../transforms/esm/http-cache.js");
+      const cacheDir = getHttpBundleCacheDir();
+      const recovered = await recoverHttpBundleByHash(hash, cacheDir);
+      if (recovered) {
+        logger.info("[ModuleLoader] HTTP bundle recovered, retrying import", { hash });
+        return await import(`file://${tempFilePath}?t=${Date.now()}&retry=1`);
+      }
+    }
+
     logger.error("[ModuleLoader] Failed to import module:", {
       filePath,
       tempFilePath,

package/src/src/server/context/cache-invalidation.ts

@@ -3,6 +3,7 @@ import {
   clearModulePathCache,
   invalidateModulePaths,
 } from "../../transforms/mdx/esm-module-loader/index.js";
+import { clearModuleCacheForProject } from "../../cache/module-cache.js";
 import {
   clearSSRModuleCache,
   clearSSRModuleCacheForProject,
@@ -63,6 +64,9 @@ export async function invalidateProjectCaches(
   });
   if (projectId) {
     clearSSRModuleCacheForProject(projectId);
+    // Also clear the pod-level module cache (used by RenderPipeline)
+    // This was previously missed, causing stale renders despite SSR module cache clearing
+    clearModuleCacheForProject(projectId);
   } else {
     clearSSRModuleCache();
   }

package/src/src/server/handlers/dev/dashboard/api.ts

@@ -360,6 +360,7 @@ async function handleListFiles(req: dntShim.Request, ctx: HandlerContext): Promi
   if (!projectDir) return errorResponse("No project directory configured", 500);
 
   const relativePath = new URL(req.url).searchParams.get("path") || "";
+  if (relativePath.includes("..")) return errorResponse("Invalid path", 400);
   const fullPath = relativePath ? `${projectDir}/${relativePath}` : projectDir;
 
   try {
@@ -394,6 +395,7 @@ async function handleReadFileContent(req: dntShim.Request, ctx: HandlerContext):
 
   const relativePath = new URL(req.url).searchParams.get("path") || "";
   if (!relativePath) return errorResponse("path parameter is required", 400);
+  if (relativePath.includes("..")) return errorResponse("Invalid path", 400);
 
   try {
     const content = await adapter.fs.readFile(`${projectDir}/${relativePath}`);

package/src/src/server/handlers/dev/projects/ui-handler.ts

@@ -83,6 +83,12 @@ export function handleProjectsUI(req: dntShim.Request): Promise<dntShim.Response
     "server.dev.projectsUI.handle",
     async () => {
       const relativePath = pathname.replace("/_projects/ui/", "").replace(/\.js$/, "");
+      if (relativePath.includes("..")) {
+        return new dntShim.Response("Invalid path", {
+          status: 400,
+          headers: { "Content-Type": "text/plain" },
+        });
+      }
       const uiDir = getUiDirectory();
 
       const module = await readUiSource(uiDir, relativePath);

package/src/src/transforms/esm/http-cache.ts

@@ -14,7 +14,6 @@ import { isAbsolute, join } from "../../platform/compat/path/index.js";
 import { cwd } from "../../platform/compat/process.js";
 import { rendererLogger as logger } from "../../utils/index.js";
 import { simpleHash } from "../../utils/hash-utils.js";
-import { Singleflight } from "../../utils/singleflight.js";
 import { LRUCache } from "../../utils/lru-wrapper.js";
 import { withSpan } from "../../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../../observability/tracing/span-names.js";
@@ -23,39 +22,20 @@ import type { ImportMapConfig } from "../../modules/import-map/types.js";
 import { isDeno } from "../../platform/compat/runtime.js";
 import { getDenoNpmReactMap, getReactImportMap, REACT_VERSION } from "./package-registry.js";
 import { parseImports, replaceSpecifiers } from "./lexer.js";
-import type { CacheBackend } from "../../cache/backend.js";
+import { CacheBackends, createDistributedCacheAccessor } from "../../cache/backend.js";
+import {
+  HTTP_MODULE_CACHE_MAX_ENTRIES,
+  HTTP_MODULE_DISTRIBUTED_TTL_SEC,
+} from "../../utils/constants/cache.js";
 
 /** Lazy-loaded distributed cache backend for cross-pod sharing */
-let distributedCache: CacheBackend | null | undefined;
-const distributedCacheInit = new Singleflight<CacheBackend | null>();
+const getDistributedCache = createDistributedCacheAccessor(
+  () => CacheBackends.httpModule(),
+  "HTTP-CACHE",
+);
 
-function getDistributedCache(): Promise<CacheBackend | null> {
-  if (distributedCache !== undefined) return Promise.resolve(distributedCache);
-
-  return distributedCacheInit.do("init", async () => {
-    try {
-      const { CacheBackends } = await import("../../cache/backend.js");
-      const backend = await CacheBackends.httpModule();
-
-      if (backend.type === "memory") {
-        distributedCache = null;
-        logger.debug("[HTTP-CACHE] No distributed cache available (memory only)");
-        return null;
-      }
-
-      distributedCache = backend;
-      logger.debug("[HTTP-CACHE] Distributed cache initialized", { type: backend.type });
-      return backend;
-    } catch (error) {
-      logger.debug("[HTTP-CACHE] Failed to initialize distributed cache", { error });
-      distributedCache = null;
-      return null;
-    }
-  });
-}
-
-/** TTL for cached modules in distributed cache (24 hours) */
-const DISTRIBUTED_CACHE_TTL_SECONDS = 86400;
+/** TTL for cached modules in distributed cache (uses centralized config) */
+const DISTRIBUTED_CACHE_TTL_SECONDS = HTTP_MODULE_DISTRIBUTED_TTL_SEC;
 
 type CacheOptions = {
   cacheDir: string;
@@ -64,7 +44,7 @@ type CacheOptions = {
   reactVersion?: string;
 };
 
-const cachedPaths = new LRUCache<string, string>({ maxEntries: 2000 });
+const cachedPaths = new LRUCache<string, string>({ maxEntries: HTTP_MODULE_CACHE_MAX_ENTRIES });
 const processingStack = new Set<string>();
 
 function ensureAbsoluteDir(path: string): string {
@@ -300,16 +280,21 @@ async function cacheHttpModule(url: string, options: CacheOptions): Promise<stri
   await fs.writeTextFile(cachePath, code);
 
   if (distributed) {
-    // Store code by URL, by hash (for direct recovery), and URL mapping (for debugging)
-    // Storing code by hash enables recovery without needing URL lookup
+    // Store code by URL, by hash (for direct recovery), and URL mapping (for debugging).
+    // Storing code by hash enables recovery without needing URL lookup.
+    // IMPORTANT: await the writes so other pods can recover this bundle immediately.
+    // Without await, a transform referencing this bundle could reach Redis before
+    // the bundle code does, causing ensureHttpBundlesExist on another pod to miss.
     const hash = simpleHash(normalizedUrl);
-    Promise.all([
-      distributed.set(normalizedUrl, code, DISTRIBUTED_CACHE_TTL_SECONDS),
-      distributed.set(`code:${hash}`, code, DISTRIBUTED_CACHE_TTL_SECONDS),
-      distributed.set(`hash:${hash}`, normalizedUrl, DISTRIBUTED_CACHE_TTL_SECONDS),
-    ]).catch((error) => {
+    try {
+      await Promise.all([
+        distributed.set(normalizedUrl, code, DISTRIBUTED_CACHE_TTL_SECONDS),
+        distributed.set(`code:${hash}`, code, DISTRIBUTED_CACHE_TTL_SECONDS),
+        distributed.set(`hash:${hash}`, normalizedUrl, DISTRIBUTED_CACHE_TTL_SECONDS),
+      ]);
+    } catch (error) {
       logger.debug("[HTTP-CACHE] Distributed cache set failed", { url: normalizedUrl, error });
-    });
+    }
   }
 
   cachedPaths.set(cacheKey, cachePath);
@@ -451,6 +436,28 @@ export async function recoverHttpBundleByHash(hash: string, cacheDir: string): P
       await fs.mkdir(absoluteCacheDir, { recursive: true });
       await fs.writeTextFile(cachePath, cachedCode);
       logger.info("[HTTP-CACHE] Bundle recovery successful (direct)", { hash, path: cachePath });
+
+      // Proactively recover transitive deps so the import retry doesn't
+      // fail again with a different missing bundle.
+      const BUNDLE_RE = /file:\/\/([^"'\s]+veryfront-http-bundle\/http-([a-f0-9]+)\.mjs)/gi;
+      const transitiveDeps: Array<{ path: string; hash: string }> = [];
+      let m;
+      while ((m = BUNDLE_RE.exec(cachedCode)) !== null) {
+        const tHash = m[2]!;
+        if (tHash !== hash) {
+          transitiveDeps.push({
+            path: join(absoluteCacheDir, `http-${tHash}.mjs`),
+            hash: tHash,
+          });
+        }
+      }
+      if (transitiveDeps.length > 0) {
+        logger.info("[HTTP-CACHE] Recovering transitive deps from last-resort recovery", {
+          count: transitiveDeps.length,
+        });
+        await ensureHttpBundlesExist(transitiveDeps, cacheDir);
+      }
+
       return true;
     }
 
@@ -494,81 +501,129 @@ export async function ensureHttpBundlesExist(
   if (bundlePaths.length === 0) return [];
 
   const fs = createFileSystem();
-  const _absoluteCacheDir = ensureAbsoluteDir(cacheDir);
-
-  // Check which bundles exist locally
-  const existenceChecks = await Promise.all(
-    bundlePaths.map(async ({ path, hash }) => ({
-      path,
-      hash,
-      exists: await exists(path),
-    })),
-  );
+  const absoluteCacheDir = ensureAbsoluteDir(cacheDir);
 
-  const missing = existenceChecks.filter((b) => !b.exists);
-  if (missing.length === 0) {
-    logger.debug("[HTTP-CACHE] All bundles exist locally", { count: bundlePaths.length });
-    return [];
-  }
+  // Use [a-f0-9]+ to match both hex and decimal hashes consistently
+  const BUNDLE_RE = /file:\/\/([^"'\s]+veryfront-http-bundle\/http-([a-f0-9]+)\.mjs)/gi;
+
+  const extractBundleRefs = (code: string): Array<{ hash: string }> => {
+    const refs: Array<{ hash: string }> = [];
+    const dedup = new Set<string>();
+    let match;
+    while ((match = BUNDLE_RE.exec(code)) !== null) {
+      const hash = match[2] as string;
+      if (!dedup.has(hash)) {
+        dedup.add(hash);
+        refs.push({ hash });
+      }
+    }
+    BUNDLE_RE.lastIndex = 0;
+    return refs;
+  };
 
-  logger.info("[HTTP-CACHE] Fetching missing bundles from distributed cache", {
-    missing: missing.length,
-    total: bundlePaths.length,
-  });
+  const pending: Array<{ hash: string }> = bundlePaths.map((b) => ({ hash: b.hash }));
+  const seen = new Set<string>();
+  const failed = new Set<string>();
 
-  const distributed = await getDistributedCache();
-  if (!distributed) {
-    logger.error("[HTTP-CACHE] No distributed cache available for bundle recovery");
-    return missing.map((m) => m.hash);
-  }
+  while (pending.length > 0) {
+    const batch = pending.splice(0, pending.length).filter((b) => !seen.has(b.hash));
+    if (batch.length === 0) break;
 
-  // Batch fetch from distributed cache
-  const codeKeys = missing.map((m) => `code:${m.hash}`);
-  let codes: Map<string, string | null>;
+    for (const item of batch) {
+      seen.add(item.hash);
+    }
 
-  try {
-    if (distributed.getBatch) {
-      codes = await distributed.getBatch(codeKeys);
-    } else {
-      // Fallback to individual gets
-      const results = await Promise.all(
-        codeKeys.map(async (key) => [key, await distributed.get(key)] as const),
-      );
-      codes = new Map(results);
+    // Check which bundles exist locally using canonical paths derived from
+    // cacheDir + hash. Don't trust caller-provided paths — they may reference
+    // a different pod's absolute directory.
+    const existenceChecks = await Promise.all(
+      batch.map(async ({ hash }) => ({
+        hash,
+        canonicalPath: join(absoluteCacheDir, `http-${hash}.mjs`),
+        exists: await exists(join(absoluteCacheDir, `http-${hash}.mjs`)),
+      })),
+    );
+
+    const missing = existenceChecks.filter((b) => !b.exists);
+    if (missing.length === 0) continue;
+
+    logger.info("[HTTP-CACHE] Fetching missing bundles from distributed cache", {
+      missing: missing.length,
+      total: batch.length,
+    });
+
+    const distributed = await getDistributedCache();
+    if (!distributed) {
+      logger.error("[HTTP-CACHE] No distributed cache available for bundle recovery");
+      for (const m of missing) failed.add(m.hash);
+      continue;
     }
-  } catch (error) {
-    logger.error("[HTTP-CACHE] Batch fetch from distributed cache failed", { error });
-    return missing.map((m) => m.hash);
-  }
 
-  // Write fetched bundles to disk
-  const failed: string[] = [];
-  await Promise.all(
-    missing.map(async ({ path, hash }) => {
-      const code = codes.get(`code:${hash}`);
-      if (!code) {
-        logger.warn("[HTTP-CACHE] Bundle not found in distributed cache", { hash });
-        failed.push(hash);
-        return;
-      }
+    // Batch fetch from distributed cache
+    const codeKeys = missing.map((m) => `code:${m.hash}`);
+    let codes: Map<string, string | null>;
 
-      try {
-        const dir = path.substring(0, path.lastIndexOf("/"));
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeTextFile(path, code);
-        logger.debug("[HTTP-CACHE] Wrote bundle to disk", { hash, path });
-      } catch (error) {
-        logger.error("[HTTP-CACHE] Failed to write bundle to disk", { hash, error });
-        failed.push(hash);
+    try {
+      if (distributed.getBatch) {
+        codes = await distributed.getBatch(codeKeys);
+      } else {
+        const results = await Promise.all(
+          codeKeys.map(async (key) => [key, await distributed.get(key)] as const),
+        );
+        codes = new Map(results);
       }
-    }),
-  );
+    } catch (error) {
+      logger.error("[HTTP-CACHE] Batch fetch from distributed cache failed", { error });
+      for (const m of missing) failed.add(m.hash);
+      continue;
+    }
+
+    // Write fetched bundles to disk using canonical paths and scan for transitive deps
+    await Promise.all(
+      missing.map(async ({ hash, canonicalPath }) => {
+        const code = codes.get(`code:${hash}`);
+        if (!code) {
+          // Try single-bundle recovery as last resort
+          const recovered = await recoverHttpBundleByHash(hash, absoluteCacheDir);
+          if (!recovered) {
+            failed.add(hash);
+          } else {
+            // Read the recovered bundle to scan for transitive deps
+            try {
+              const recoveredCode = await fs.readTextFile(canonicalPath);
+              for (const ref of extractBundleRefs(recoveredCode)) {
+                if (!seen.has(ref.hash)) pending.push(ref);
+              }
+            } catch { /* ignore read errors for dep scanning */ }
+          }
+          return;
+        }
+
+        try {
+          await fs.mkdir(absoluteCacheDir, { recursive: true });
+          await fs.writeTextFile(canonicalPath, code);
+          logger.debug("[HTTP-CACHE] Wrote bundle to disk", { hash, path: canonicalPath });
+
+          // Scan recovered code for transitive HTTP bundle dependencies.
+          // HTTP bundles import other bundles (e.g., esm.sh packages depending
+          // on other packages). Without this, Pod B recovers only the top-level
+          // bundle and gets "Module not found" for transitive deps at import time.
+          for (const ref of extractBundleRefs(code)) {
+            if (!seen.has(ref.hash)) pending.push(ref);
+          }
+        } catch (error) {
+          logger.error("[HTTP-CACHE] Failed to write bundle to disk", { hash, error });
+          failed.add(hash);
+        }
+      }),
+    );
+  }
 
-  if (failed.length > 0) {
-    logger.warn("[HTTP-CACHE] Some bundles could not be recovered", { failed });
-  } else {
-    logger.info("[HTTP-CACHE] All missing bundles recovered", { count: missing.length });
+  if (failed.size > 0) {
+    logger.warn("[HTTP-CACHE] Some bundles could not be recovered", {
+      failed: Array.from(failed),
+    });
   }
 
-  return failed;
+  return Array.from(failed);
 }