veryfront 0.0.80 → 0.0.82

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

@@ -50,7 +50,31 @@ import {
   transformSemaphore,
 } from "./cache/index.js";
 import type { ModuleCacheEntry, SSRModuleLoaderOptions } from "./types.js";
-import { getCacheBaseDir } from "../../../utils/cache-dir.js";
+import { getCacheBaseDir, getHttpBundleCacheDir } from "../../../utils/cache-dir.js";
+import { ensureHttpBundlesExist } from "../../../transforms/esm/http-cache.js";
+
+/** 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;
+}
+
+/** Track temp paths that have been verified for HTTP bundles to avoid redundant I/O */
+const verifiedHttpBundlePaths = new Set<string>();
 
 /**
  * SSR Module Loader with Redis Support.
@@ -100,11 +124,45 @@ export class SSRModuleLoader {
             );
           }
 
-          const mod = await withSpan(
-            SpanNames.SSR_DYNAMIC_IMPORT,
-            () => import(`file://${cacheEntry.tempPath}?v=${cacheEntry.contentHash}`),
-            { "ssr.file": fileName },
-          );
+          let mod: Record<string, unknown>;
+          try {
+            mod = await withSpan(
+              SpanNames.SSR_DYNAMIC_IMPORT,
+              () => import(`file://${cacheEntry.tempPath}?v=${cacheEntry.contentHash}`),
+              { "ssr.file": fileName },
+            ) as Record<string, unknown>;
+          } catch (importError) {
+            // If import fails due to missing HTTP bundle, try to recover and retry once
+            const errorMsg = importError instanceof Error
+              ? importError.message
+              : String(importError);
+            const bundleMatch = errorMsg.match(/veryfront-http-bundle\/http-([a-f0-9]+)\.mjs/);
+            if (bundleMatch) {
+              const hash = bundleMatch[1]!;
+              logger.warn(
+                "[SSR-MODULE-LOADER] Import failed due to missing HTTP bundle, attempting recovery",
+                {
+                  file: filePath.slice(-40),
+                  hash,
+                },
+              );
+              const { recoverHttpBundleByHash } = await import(
+                "../../../transforms/esm/http-cache.js"
+              );
+              const cacheDir = getHttpBundleCacheDir();
+              const recovered = await recoverHttpBundleByHash(hash, cacheDir);
+              if (recovered) {
+                logger.info("[SSR-MODULE-LOADER] HTTP bundle recovered, retrying import", { hash });
+                mod = await import(
+                  `file://${cacheEntry.tempPath}?v=${cacheEntry.contentHash}&retry=1`
+                ) as Record<string, unknown>;
+              } else {
+                throw importError;
+              }
+            } else {
+              throw importError;
+            }
+          }
 
           failedComponents.delete(circuitKey);
           return extractComponent(mod, filePath);
@@ -372,9 +430,44 @@ export class SSRModuleLoader {
 
     const cachedEntry = globalModuleCache.get(contentCacheKey);
     if (cachedEntry) {
-      globalModuleCache.set(filePathCacheKey, cachedEntry);
-      await this.ensureDependenciesExist(code, filePath, depth);
-      return;
+      // Verify HTTP bundles exist for in-memory cached transforms (once per path)
+      if (!verifiedHttpBundlePaths.has(cachedEntry.tempPath)) {
+        try {
+          const cachedCode = await this.fs.readTextFile(cachedEntry.tempPath);
+          const bundlePaths = extractHttpBundlePaths(cachedCode);
+          if (bundlePaths.length > 0) {
+            const cacheDir = getHttpBundleCacheDir();
+            const failed = await ensureHttpBundlesExist(bundlePaths, cacheDir);
+            if (failed.length > 0) {
+              logger.warn(
+                "[SSR-MODULE-LOADER] In-memory cached module has unrecoverable HTTP bundles, re-transforming",
+                {
+                  file: filePath.slice(-40),
+                  failed,
+                },
+              );
+              globalModuleCache.delete(contentCacheKey);
+              globalModuleCache.delete(filePathCacheKey);
+              // Fall through to Redis or fresh transform
+            } else {
+              verifiedHttpBundlePaths.add(cachedEntry.tempPath);
+            }
+          } else {
+            verifiedHttpBundlePaths.add(cachedEntry.tempPath);
+          }
+        } catch {
+          // File doesn't exist or unreadable, invalidate cache
+          globalModuleCache.delete(contentCacheKey);
+          globalModuleCache.delete(filePathCacheKey);
+        }
+      }
+
+      // Re-check after potential invalidation
+      if (globalModuleCache.has(contentCacheKey)) {
+        globalModuleCache.set(filePathCacheKey, cachedEntry);
+        await this.ensureDependenciesExist(code, filePath, depth);
+        return;
+      }
     }
 
     const redisEnabled = getRedisEnabled();
@@ -382,18 +475,44 @@ export class SSRModuleLoader {
     if (redisEnabled && redisClient) {
       const redisCode = await getFromRedis(contentCacheKey);
       if (redisCode) {
-        const tempPath = await this.getTempPath(filePath, contentHash);
-        await this.fs.mkdir(tempPath.substring(0, tempPath.lastIndexOf("/")), { recursive: true });
-        await this.fs.writeTextFile(tempPath, redisCode);
+        // Proactively ensure HTTP bundles exist before using cached transform.
+        // The cached code may reference file:// paths to HTTP bundles that were
+        // created on a different pod and may not exist locally.
+        let httpBundlesOk = true;
+        const bundlePaths = extractHttpBundlePaths(redisCode);
+        if (bundlePaths.length > 0) {
+          const cacheDir = getHttpBundleCacheDir();
+          const failed = await ensureHttpBundlesExist(bundlePaths, cacheDir);
+          if (failed.length > 0) {
+            logger.warn(
+              "[SSR-MODULE-LOADER] Redis cached code has unrecoverable HTTP bundles, re-transforming",
+              {
+                file: filePath.slice(-40),
+                failed,
+              },
+            );
+            httpBundlesOk = false;
+          }
+        }
 
-        const entry: ModuleCacheEntry = { tempPath, contentHash };
-        globalModuleCache.set(contentCacheKey, entry);
-        globalModuleCache.set(filePathCacheKey, entry);
+        if (httpBundlesOk) {
+          const tempPath = await this.getTempPath(filePath, contentHash);
+          await this.fs.mkdir(tempPath.substring(0, tempPath.lastIndexOf("/")), {
+            recursive: true,
+          });
+          await this.fs.writeTextFile(tempPath, redisCode);
+          verifiedHttpBundlePaths.add(tempPath);
 
-        logger.debug("[SSR-MODULE-LOADER] Redis cache hit", { file: filePath.slice(-40) });
+          const entry: ModuleCacheEntry = { tempPath, contentHash };
+          globalModuleCache.set(contentCacheKey, entry);
+          globalModuleCache.set(filePathCacheKey, entry);
 
-        await this.ensureDependenciesExist(code, filePath, depth);
-        return;
+          logger.debug("[SSR-MODULE-LOADER] Redis cache hit", { file: filePath.slice(-40) });
+
+          await this.ensureDependenciesExist(code, filePath, depth);
+          return;
+        }
+        // Fall through to re-transform, which will create HTTP bundles locally
       }
     }
 

package/src/src/observability/tracing/span-names.ts

@@ -98,6 +98,8 @@ export const SpanNames = {
   CACHE_REGISTRY_DELETE_REDIS_KEYS: "cache.registry.delete_redis_keys",
   CACHE_KEYS_GET_ALL_ASYNC: "cache.keys.get_all_async",
   CACHE_KEYS_DELETE_ALL_ASYNC: "cache.keys.delete_all_async",
+  CACHE_MULTI_TIER_GET: "cache.multi_tier.get",
+  CACHE_MULTI_TIER_SET: "cache.multi_tier.set",
 
   HTML_GENERATE_SHELL_PARTS: "html.generate_shell_parts",
   HTML_WRAP_IN_SHELL: "html.wrap_in_shell",

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/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 {

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

@@ -156,6 +156,59 @@ export function destroyTransformCache(): void {
   localFallback.clear();
 }
 
+/**
+ * Get the underlying distributed cache backend.
+ *
+ * This is exposed for callers that need direct access to the distributed
+ * cache (e.g., MDX module-fetcher that stores raw code strings instead of
+ * TransformCacheEntry JSON). Ensures initialization happens only once.
+ *
+ * Returns null if distributed cache is not available (memory-only mode).
+ */
+export async function getDistributedTransformBackend(): Promise<CacheBackend | null> {
+  await initializeTransformCache();
+  if (!cacheBackend || cacheBackend.type === "memory") return null;
+  return cacheBackend;
+}
+
+/**
+ * Get a cached transform or compute it if not found.
+ *
+ * This is the preferred way to use the transform cache - it handles:
+ * - Cache lookup (distributed first, then local fallback)
+ * - Compute on miss
+ * - Cache storage on compute
+ *
+ * @param key - Cache key (use generateCacheKey to build it)
+ * @param computeFn - Function to compute the transform if not cached
+ * @param ttlSeconds - TTL for the cached entry
+ * @returns The cached or computed code
+ */
+export async function getOrComputeTransform(
+  key: string,
+  computeFn: () => Promise<string>,
+  ttlSeconds: number = DEFAULT_TTL_SECONDS,
+): Promise<string> {
+  // Try to get from cache first
+  const cached = await getCachedTransformAsync(key);
+  if (cached) {
+    logger.debug("[TransformCache] Cache hit", { key });
+    return cached.code;
+  }
+
+  // Compute on miss
+  logger.debug("[TransformCache] Cache miss, computing", { key });
+  const code = await computeFn();
+
+  // Store in cache (fire-and-forget for performance)
+  const hash = String(Date.now()); // Simple hash for now
+  setCachedTransformAsync(key, code, hash, ttlSeconds).catch((error) => {
+    logger.debug("[TransformCache] Failed to cache computed transform", { key, error });
+  });
+
+  return code;
+}
+
 export function getTransformCacheStats(): {
   fallbackEntries: number;
   maxFallbackEntries: number;

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/index.ts

@@ -16,11 +16,9 @@ import * as dntShim from "../../../../../_dnt.shims.js";
 
 import { join, posix } from "../../../../../deps/deno.land/std@0.220.0/path/mod.js";
 import { rendererLogger as logger } from "../../../../utils/index.js";
-import { Singleflight } from "../../../../utils/singleflight.js";
 import { withSpan } from "../../../../observability/tracing/otlp-setup.js";
 import { SpanNames } from "../../../../observability/tracing/span-names.js";
 import type { RuntimeAdapter } from "../../../../platform/adapters/base.js";
-import type { CacheBackend } from "../../../../cache/backend.js";
 import { transformToESM } from "../../../esm-transform.js";
 import { TRANSFORM_CACHE_VERSION } from "../../../esm/package-registry.js";
 import { ensureHttpBundlesExist } from "../../../esm/http-cache.js";
@@ -37,48 +35,12 @@ import { hashString } from "../utils/hash.js";
 import { createStubModule } from "../utils/stub-module.js";
 import { resolveModuleFile } from "../resolution/file-finder.js";
 import { recordSSRModules } from "../../../../modules/manifest/route-module-manifest.js";
+import { getDistributedTransformBackend } from "../../../esm/transform-cache.js";
 import { TRANSFORM_DISTRIBUTED_TTL_SEC } from "../../../../utils/constants/cache.js";
 
-/**
- * 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 (uses centralized config) */
 const TRANSFORM_CACHE_TTL_SECONDS = TRANSFORM_DISTRIBUTED_TTL_SEC;
 
-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(`${LOG_PREFIX_MDX_LOADER} No distributed transform cache (memory only)`);
-        return null;
-      }
-
-      distributedTransformCache = backend;
-      logger.debug(`${LOG_PREFIX_MDX_LOADER} Distributed transform cache initialized`, {
-        type: backend.type,
-      });
-      return backend;
-    } catch (error) {
-      logger.debug(`${LOG_PREFIX_MDX_LOADER} Failed to init distributed transform cache`, {
-        error,
-      });
-      distributedTransformCache = null;
-      return null;
-    }
-  });
-}
-
 /**
  * Build cache key for transformed module.
  * Includes content hash so cache invalidates when source changes.
@@ -554,7 +516,7 @@ async function doFetchAndCacheModule(
     const transformCacheKey = getTransformCacheKey(projectId, normalizedPath, contentHash);
 
     let moduleCode: string | null = null;
-    const distributedCache = await getDistributedTransformCache();
+    const distributedCache = await getDistributedTransformBackend();
 
     if (distributedCache) {
       try {