veryfront 0.0.80 → 0.0.82

package/esm/src/rendering/orchestrator/module-loader/index.js

@@ -6,69 +6,41 @@
  * @module rendering/orchestrator/module-loader
  */
 import { parallelMap, rendererLogger as logger } from "../../../utils/index.js";
-import { Singleflight } from "../../../utils/singleflight.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();
-/**
- * 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;
-const distributedCacheInit = new Singleflight();
-/** TTL for cached transforms (24 hours) */
-const TRANSFORM_CACHE_TTL_SECONDS = 86400;
-function getDistributedTransformCache() {
-    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;
+/** 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) {
+    const bundles = [];
+    const seen = new Set();
+    let match;
+    while ((match = HTTP_BUNDLE_PATTERN.exec(code)) !== null) {
+        const path = match[1];
+        const hash = match[2];
+        if (!seen.has(hash)) {
+            seen.add(hash);
+            bundles.push({ path, hash });
         }
-        catch (error) {
-            logger.debug("[ModuleLoader] 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.
- */
-function getTransformCacheKey(projectId, filePath, contentHash) {
-    return `v${TRANSFORM_CACHE_VERSION}:${projectId}:${filePath}:${contentHash}`;
-}
-/** Simple string hash for cache keys */
-function hashString(str) {
-    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);
+    HTTP_BUNDLE_PATTERN.lastIndex = 0;
+    return bundles;
 }
+/** Cache for created directories to avoid repeated mkdir calls */
+const createdDirs = new Set();
+/** TTL for cached transforms (uses centralized config) */
+const TRANSFORM_CACHE_TTL_SECONDS = TRANSFORM_DISTRIBUTED_TTL_SEC;
 function getModuleCacheKey(filePath, projectId, projectDir) {
     return `${projectId ?? projectDir ?? "default"}:${filePath}`;
 }
@@ -154,35 +126,41 @@ export async function transformModuleWithDeps(filePath, tmpDir, localAdapter, co
     }
     const contentHash = hashString(fileContent);
     const effectiveProjectId = projectId ?? projectDir;
-    const transformCacheKey = getTransformCacheKey(effectiveProjectId, filePath, contentHash);
-    let transformedCode = null;
-    const distributedCache = await getDistributedTransformCache();
-    if (distributedCache) {
-        try {
-            const cached = await distributedCache.get(transformCacheKey);
-            if (cached) {
-                transformedCode = cached;
-                logger.debug("[ModuleLoader] Distributed transform cache HIT", {
-                    filePath,
-                    cacheKey: transformCacheKey,
-                });
-            }
-        }
-        catch (error) {
-            logger.debug("[ModuleLoader] Distributed cache get failed", { filePath, error });
-        }
-    }
-    if (!transformedCode) {
-        transformedCode = await transformToESM(fileContent, filePath, projectDir, adapter, {
+    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,
         });
-        if (distributedCache) {
-            distributedCache
-                .set(transformCacheKey, transformedCode, TRANSFORM_CACHE_TTL_SECONDS)
-                .catch((error) => {
-                logger.debug("[ModuleLoader] Distributed cache set failed", { filePath, error });
+    }, TRANSFORM_CACHE_TTL_SECONDS);
+    // 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,
+                    error,
+                });
             });
         }
     }
@@ -219,6 +197,23 @@ export async function loadModule(filePath, config) {
         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/esm/src/transforms/esm/http-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-cache.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAsCzE,KAAK,YAAY,GAAG;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,eAAe,CAAC;IAC3B,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAoUF;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOvF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAwC9F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAClD,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,EAAE,CAAC,CAiFnB"}
+{"version":3,"file":"http-cache.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/http-cache.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAmBzE,KAAK,YAAY,GAAG;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,eAAe,CAAC;IAC3B,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAoUF;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOvF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAwC9F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAClD,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,EAAE,CAAC,CAiFnB"}

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

@@ -12,7 +12,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";
@@ -20,35 +19,13 @@ import { resolveImport } from "../../modules/import-map/resolver.js";
 import { isDeno } from "../../platform/compat/runtime.js";
 import { getDenoNpmReactMap, getReactImportMap, REACT_VERSION } from "./package-registry.js";
 import { parseImports, replaceSpecifiers } from "./lexer.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;
-const distributedCacheInit = new Singleflight();
-function getDistributedCache() {
-    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;
-const cachedPaths = new LRUCache({ maxEntries: 2000 });
+const getDistributedCache = createDistributedCacheAccessor(() => CacheBackends.httpModule(), "HTTP-CACHE");
+/** TTL for cached modules in distributed cache (uses centralized config) */
+const DISTRIBUTED_CACHE_TTL_SECONDS = HTTP_MODULE_DISTRIBUTED_TTL_SEC;
+const cachedPaths = new LRUCache({ maxEntries: HTTP_MODULE_CACHE_MAX_ENTRIES });
 const processingStack = new Set();
 function ensureAbsoluteDir(path) {
     return isAbsolute(path) ? path : join(cwd(), path);

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

@@ -1,3 +1,4 @@
+import { type CacheBackend } from "../../cache/backend.js";
 export interface TransformCacheEntry {
     code: string;
     hash: string;
@@ -15,6 +16,30 @@ export declare function getCachedTransform(key: string): TransformCacheEntry | u
 export declare function setCachedTransformAsync(key: string, code: string, hash: string, ttlSeconds?: number): Promise<void>;
 export declare function setCachedTransform(key: string, code: string, hash: string, ttlSeconds?: number): void;
 export declare function destroyTransformCache(): void;
+/**
+ * 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 declare function getDistributedTransformBackend(): Promise<CacheBackend | null>;
+/**
+ * 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 declare function getOrComputeTransform(key: string, computeFn: () => Promise<string>, ttlSeconds?: number): Promise<string>;
 export declare function getTransformCacheStats(): {
     fallbackEntries: number;
     maxFallbackEntries: number;

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

@@ -1 +1 @@
-{"version":3,"file":"transform-cache.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/transform-cache.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAeD,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,OAAO,CAAC,CAuBjE;AAED,wBAAgB,yBAAyB,IAAI,OAAO,CAEnD;AAED,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,iCAA2B,CAAC;AAE7D,wDAAwD;AACxD,eAAO,MAAM,mBAAmB,kCAA4B,CAAC;AAE7D,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,GAAG,GAAE,OAAe,EACpB,WAAW,GAAE,OAAe,GAC3B,MAAM,CAER;AAED,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAW1C;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAG/E;AAED,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,MAA4B,GACvC,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,MAA4B,GACvC,IAAI,CAeN;AAuBD,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED,wBAAgB,sBAAsB,IAAI;IACxC,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAMA"}
+{"version":3,"file":"transform-cache.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/esm/transform-cache.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,YAAY,EAAqC,MAAM,wBAAwB,CAAC;AAK9F,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAeD,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,OAAO,CAAC,CAuBjE;AAED,wBAAgB,yBAAyB,IAAI,OAAO,CAEnD;AAED,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,iCAA2B,CAAC;AAE7D,wDAAwD;AACxD,eAAO,MAAM,mBAAmB,kCAA4B,CAAC;AAE7D,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,GAAG,GAAE,OAAe,EACpB,WAAW,GAAE,OAAe,GAC3B,MAAM,CAER;AAED,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAW1C;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAG/E;AAED,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,MAA4B,GACvC,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,GAAE,MAA4B,GACvC,IAAI,CAeN;AAuBD,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAED;;;;;;;;GAQG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAInF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAChC,UAAU,GAAE,MAA4B,GACvC,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED,wBAAgB,sBAAsB,IAAI;IACxC,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAMA"}

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

@@ -110,6 +110,51 @@ function pruneLocalFallback() {
 export function destroyTransformCache() {
     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() {
+    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, computeFn, ttlSeconds = DEFAULT_TTL_SECONDS) {
+    // 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() {
     return {
         fallbackEntries: localFallback.size,

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/src/transforms/mdx/esm-module-loader/module-fetcher/index.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAY5E,OAAO,KAAK,EAAE,oBAAoB,EAAsB,MAAM,aAAa,CAAC;AAgI5E;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,IAAI,CAON;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAiCxD;AAsND;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA6CxB;AA4OD;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACvD,oBAAoB,CAUtB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/src/transforms/mdx/esm-module-loader/module-fetcher/index.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAW5E,OAAO,KAAK,EAAE,oBAAoB,EAAsB,MAAM,aAAa,CAAC;AA4F5E;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,IAAI,CAON;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAiCxD;AAsND;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA6CxB;AA4OD;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,cAAc,EACvB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACvD,oBAAoB,CAUtB"}

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

@@ -14,7 +14,6 @@
 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 { transformToESM } from "../../../esm-transform.js";
@@ -27,43 +26,10 @@ 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;
-const distributedCacheInit = new Singleflight();
 /** TTL for cached transforms (uses centralized config) */
 const TRANSFORM_CACHE_TTL_SECONDS = TRANSFORM_DISTRIBUTED_TTL_SEC;
-function getDistributedTransformCache() {
-    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.
@@ -415,7 +381,7 @@ async function doFetchAndCacheModule(normalizedPath, context, fetchAndCacheModul
         const contentHash = hashString(sourceCode);
         const transformCacheKey = getTransformCacheKey(projectId, normalizedPath, contentHash);
         let moduleCode = null;
-        const distributedCache = await getDistributedTransformCache();
+        const distributedCache = await getDistributedTransformBackend();
         if (distributedCache) {
             try {
                 const cached = await distributedCache.get(transformCacheKey);

package/esm/src/utils/constants/cache.d.ts

@@ -51,4 +51,8 @@ export declare const REVALIDATION_TIMEOUT_MS: number;
 export declare const HTTP_MODULE_CACHE_MAX_ENTRIES: number;
 export declare const HTTP_MODULE_DISTRIBUTED_TTL_SEC: number;
 export declare const TRANSFORM_DISTRIBUTED_TTL_SEC: number;
+export declare const MODULE_CACHE_MAX_ENTRIES: number;
+export declare const MODULE_CACHE_TTL_MS: number;
+export declare const ESM_CACHE_MAX_ENTRIES: number;
+export declare const ESM_CACHE_TTL_MS: number;
 //# sourceMappingURL=cache.d.ts.map

package/esm/src/utils/constants/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/constants/cache.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC,eAAO,MAAM,aAAa,QAAqC,CAAC;AAChE,eAAO,MAAM,WAAW,QAAmC,CAAC;AAC5D,eAAO,MAAM,UAAU,QAA8B,CAAC;AAyBtD,eAAO,MAAM,uBAAuB,QAA+C,CAAC;AAEpF,eAAO,MAAM,4BAA4B,QAAoD,CAAC;AAC9F,eAAO,MAAM,uBAAuB,QAAqB,CAAC;AAE1D,eAAO,MAAM,wBAAwB,QAAgD,CAAC;AACtF,eAAO,MAAM,mBAAmB,QAAqB,CAAC;AAEtD,eAAO,MAAM,yBAAyB,QAAiD,CAAC;AACxF,eAAO,MAAM,oBAAoB,QAAoB,CAAC;AAEtD,eAAO,MAAM,sBAAsB,QAA8C,CAAC;AAClF,eAAO,MAAM,iBAAiB,QAAqB,CAAC;AAEpD,eAAO,MAAM,yBAAyB,QAAiD,CAAC;AACxF,eAAO,MAAM,oBAAoB,QAAqB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,QAAa,CAAC;AACtD,eAAO,MAAM,4BAA4B,QAAoB,CAAC;AAE9D,eAAO,MAAM,8BAA8B,QAAa,CAAC;AACzD,eAAO,MAAM,+BAA+B,QAAoB,CAAC;AAEjE,eAAO,MAAM,2BAA2B,QAAiB,CAAC;AAC1D,eAAO,MAAM,0BAA0B,QAAc,CAAC;AAEtD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,eAAO,MAAM,6BAA6B,QAAwC,CAAC;AAMnF,eAAO,MAAM,yCAAyC,QAGrD,CAAC;AACF,eAAO,MAAM,sCAAsC,QAGlD,CAAC;AAEF,eAAO,MAAM,wCAAwC,QAGpD,CAAC;AACF,eAAO,MAAM,qCAAqC,QAGjD,CAAC;AAEF,eAAO,MAAM,mCAAmC,QAG/C,CAAC;AACF,eAAO,MAAM,gCAAgC,QAG5C,CAAC;AAEF,eAAO,MAAM,kCAAkC,QAG9C,CAAC;AACF,eAAO,MAAM,+BAA+B,QAG3C,CAAC;AAEF,6DAA6D;AAC7D,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,YAAY,GAAG,WAAW,GAAG,MAAM,GAAG,KAAK,EACtD,YAAY,GAAE,OAA4B,GACzC,MAAM,CAeR;AAGD,eAAO,MAAM,6BAA6B,QAAS,CAAC;AACpD,eAAO,MAAM,0BAA0B,QAAwC,CAAC;AAChF,eAAO,MAAM,0BAA0B,QAAqD,CAAC;AAC7F,eAAO,MAAM,wBAAwB,QAAiD,CAAC;AACvF,eAAO,MAAM,sBAAsB,QAA+C,CAAC;AACnF,eAAO,MAAM,sBAAsB,QAA8C,CAAC;AAGlF,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAC/C,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAClD,eAAO,MAAM,2BAA2B,WAAW,CAAC;AAGpD,eAAO,MAAM,yBAAyB,QAAQ,CAAC;AAC/C,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAG7C,eAAO,MAAM,4BAA4B,QAAmD,CAAC;AAC7F,eAAO,MAAM,2BAA2B,QAAkD,CAAC;AAC3F,eAAO,MAAM,uBAAuB,QAAiD,CAAC;AAItF,eAAO,MAAM,6BAA6B,QAAsD,CAAC;AACjG,eAAO,MAAM,+BAA+B,QAG3C,CAAC;AAIF,eAAO,MAAM,6BAA6B,QAGzC,CAAC"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../../src/src/utils/constants/cache.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC,eAAO,MAAM,aAAa,QAAqC,CAAC;AAChE,eAAO,MAAM,WAAW,QAAmC,CAAC;AAC5D,eAAO,MAAM,UAAU,QAA8B,CAAC;AA8BtD,eAAO,MAAM,uBAAuB,QAA+C,CAAC;AAEpF,eAAO,MAAM,4BAA4B,QAAoD,CAAC;AAC9F,eAAO,MAAM,uBAAuB,QAAqB,CAAC;AAE1D,eAAO,MAAM,wBAAwB,QAAgD,CAAC;AACtF,eAAO,MAAM,mBAAmB,QAAqB,CAAC;AAEtD,eAAO,MAAM,yBAAyB,QAAiD,CAAC;AACxF,eAAO,MAAM,oBAAoB,QAAoB,CAAC;AAEtD,eAAO,MAAM,sBAAsB,QAA8C,CAAC;AAClF,eAAO,MAAM,iBAAiB,QAAqB,CAAC;AAEpD,eAAO,MAAM,yBAAyB,QAAiD,CAAC;AACxF,eAAO,MAAM,oBAAoB,QAAqB,CAAC;AAEvD,eAAO,MAAM,2BAA2B,QAAa,CAAC;AACtD,eAAO,MAAM,4BAA4B,QAAoB,CAAC;AAE9D,eAAO,MAAM,8BAA8B,QAAa,CAAC;AACzD,eAAO,MAAM,+BAA+B,QAAoB,CAAC;AAEjE,eAAO,MAAM,2BAA2B,QAAiB,CAAC;AAC1D,eAAO,MAAM,0BAA0B,QAAc,CAAC;AAEtD,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,eAAO,MAAM,6BAA6B,QAAwC,CAAC;AAMnF,eAAO,MAAM,yCAAyC,QAGrD,CAAC;AACF,eAAO,MAAM,sCAAsC,QAGlD,CAAC;AAEF,eAAO,MAAM,wCAAwC,QAGpD,CAAC;AACF,eAAO,MAAM,qCAAqC,QAGjD,CAAC;AAEF,eAAO,MAAM,mCAAmC,QAG/C,CAAC;AACF,eAAO,MAAM,gCAAgC,QAG5C,CAAC;AAEF,eAAO,MAAM,kCAAkC,QAG9C,CAAC;AACF,eAAO,MAAM,+BAA+B,QAG3C,CAAC;AAEF,6DAA6D;AAC7D,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,YAAY,GAAG,WAAW,GAAG,MAAM,GAAG,KAAK,EACtD,YAAY,GAAE,OAA4B,GACzC,MAAM,CAeR;AAGD,eAAO,MAAM,6BAA6B,QAAS,CAAC;AACpD,eAAO,MAAM,0BAA0B,QAAwC,CAAC;AAChF,eAAO,MAAM,0BAA0B,QAAqD,CAAC;AAC7F,eAAO,MAAM,wBAAwB,QAAiD,CAAC;AACvF,eAAO,MAAM,sBAAsB,QAA+C,CAAC;AACnF,eAAO,MAAM,sBAAsB,QAA8C,CAAC;AAGlF,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAC/C,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAClD,eAAO,MAAM,2BAA2B,WAAW,CAAC;AAGpD,eAAO,MAAM,yBAAyB,QAAQ,CAAC;AAC/C,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAG7C,eAAO,MAAM,4BAA4B,QAAmD,CAAC;AAC7F,eAAO,MAAM,2BAA2B,QAAkD,CAAC;AAC3F,eAAO,MAAM,uBAAuB,QAAiD,CAAC;AAItF,eAAO,MAAM,6BAA6B,QAAsD,CAAC;AACjG,eAAO,MAAM,+BAA+B,QAG3C,CAAC;AAIF,eAAO,MAAM,6BAA6B,QAGzC,CAAC;AAIF,eAAO,MAAM,wBAAwB,QAAkD,CAAC;AACxF,eAAO,MAAM,mBAAmB,QAG/B,CAAC;AAGF,eAAO,MAAM,qBAAqB,QAA8C,CAAC;AACjF,eAAO,MAAM,gBAAgB,QAG5B,CAAC"}

package/esm/src/utils/constants/cache.js

@@ -8,7 +8,13 @@ export const MS_PER_HOUR = MINUTES_PER_HOUR * MS_PER_MINUTE;
 export const ONE_DAY_MS = HOURS_PER_DAY * MS_PER_HOUR;
 function getEnvString(key) {
     const g = dntShim.dntGlobalThis;
-    return g.Deno?.env?.get?.(key) ?? g.process?.env?.[key];
+    try {
+        return g.Deno?.env?.get?.(key) ?? g.process?.env?.[key];
+    }
+    catch {
+        // Gracefully handle missing --allow-env permission in Deno
+        return undefined;
+    }
 }
 function getEnvNumber(key, fallback) {
     const value = getEnvString(key);
@@ -95,3 +101,10 @@ export const HTTP_MODULE_DISTRIBUTED_TTL_SEC = getEnvNumber("HTTP_MODULE_DISTRIB
 // Transform cache for module compilation
 // Same TTL as HTTP module cache since transforms are tied to content hashes
 export const TRANSFORM_DISTRIBUTED_TTL_SEC = getEnvNumber("TRANSFORM_DISTRIBUTED_TTL_SEC", HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE);
+// Pod-level module cache (shared across all RenderPipeline instances)
+// These caches map module paths to transformed temp file paths
+export const MODULE_CACHE_MAX_ENTRIES = getEnvNumber("MODULE_CACHE_MAX_ENTRIES", 10000);
+export const MODULE_CACHE_TTL_MS = getEnvNumber("MODULE_CACHE_TTL_MS", 5 * MS_PER_MINUTE);
+// ESM cache for external module mappings
+export const ESM_CACHE_MAX_ENTRIES = getEnvNumber("ESM_CACHE_MAX_ENTRIES", 5000);
+export const ESM_CACHE_TTL_MS = getEnvNumber("ESM_CACHE_TTL_MS", 10 * MS_PER_MINUTE);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "description": "Zero-config React meta-framework for building agentic AI applications",
   "keywords": [
     "react",

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "nodeModulesDir": "auto",
   "exclude": [
     "npm/",

package/src/src/cache/backend.ts

@@ -587,6 +587,68 @@ export function createCacheBackend(config: CacheBackendConfig = {}): Promise<Cac
   );
 }
 
+/**
+ * Check if a cache backend supports distributed (cross-pod) caching.
+ *
+ * Use this instead of checking `backend.type === "memory"` directly,
+ * which is a leaky abstraction that exposes implementation details.
+ */
+export function isDistributedBackend(backend: CacheBackend): boolean {
+  return backend.type !== "memory";
+}
+
+/**
+ * Create a lazy-initialized distributed cache accessor.
+ *
+ * This encapsulates the common pattern of:
+ * 1. Lazy-init a cache backend via Singleflight
+ * 2. Skip if memory-only (not useful for cross-pod sharing)
+ * 3. Return null if init fails
+ *
+ * @param factory - Function that creates the cache backend
+ * @param name - Log prefix for debug messages
+ * @returns A function that returns the distributed cache backend or null
+ */
+export function createDistributedCacheAccessor(
+  factory: () => Promise<CacheBackend>,
+  name: string,
+): () => Promise<CacheBackend | null> {
+  let backend: CacheBackend | null | undefined;
+  const singleflight = new (class {
+    private promise: Promise<CacheBackend | null> | null = null;
+    do(fn: () => Promise<CacheBackend | null>): Promise<CacheBackend | null> {
+      if (!this.promise) {
+        this.promise = fn().finally(() => {
+          this.promise = null;
+        });
+      }
+      return this.promise;
+    }
+  })();
+
+  return () => {
+    if (backend !== undefined) return Promise.resolve(backend);
+
+    return singleflight.do(async () => {
+      try {
+        const b = await factory();
+        if (!isDistributedBackend(b)) {
+          backend = null;
+          logger.debug(`[${name}] No distributed cache available (memory only)`);
+          return null;
+        }
+        backend = b;
+        logger.debug(`[${name}] Distributed cache initialized`, { type: b.type });
+        return b;
+      } catch (error) {
+        logger.debug(`[${name}] Failed to initialize distributed cache`, { error });
+        backend = null;
+        return null;
+      }
+    });
+  };
+}
+
 /** Convenience wrappers for common cache patterns. */
 export const CacheBackends = {
   /** Transform cache for compiled code. */