veryfront 0.0.81 → 0.0.83

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);
@@ -247,16 +224,22 @@ async function cacheHttpModule(url, options) {
     await fs.mkdir(cacheDir, { recursive: true });
     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);
     return cachePath;
@@ -365,6 +348,26 @@ export async function recoverHttpBundleByHash(hash, cacheDir) {
             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 = [];
+            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;
         }
         // Strategy 2: URL lookup then re-fetch (fallback for bundles cached before code:{hash} was added)
@@ -403,69 +406,118 @@ export async function ensureHttpBundlesExist(bundlePaths, cacheDir) {
     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 missing = existenceChecks.filter((b) => !b.exists);
-    if (missing.length === 0) {
-        logger.debug("[HTTP-CACHE] All bundles exist locally", { count: bundlePaths.length });
-        return [];
-    }
-    logger.info("[HTTP-CACHE] Fetching missing bundles from distributed cache", {
-        missing: missing.length,
-        total: bundlePaths.length,
-    });
-    const distributed = await getDistributedCache();
-    if (!distributed) {
-        logger.error("[HTTP-CACHE] No distributed cache available for bundle recovery");
-        return missing.map((m) => m.hash);
-    }
-    // Batch fetch from distributed cache
-    const codeKeys = missing.map((m) => `code:${m.hash}`);
-    let codes;
-    try {
-        if (distributed.getBatch) {
-            codes = await distributed.getBatch(codeKeys);
+    const absoluteCacheDir = ensureAbsoluteDir(cacheDir);
+    // 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) => {
+        const refs = [];
+        const dedup = new Set();
+        let match;
+        while ((match = BUNDLE_RE.exec(code)) !== null) {
+            const hash = match[2];
+            if (!dedup.has(hash)) {
+                dedup.add(hash);
+                refs.push({ hash });
+            }
         }
-        else {
-            // Fallback to individual gets
-            const results = await Promise.all(codeKeys.map(async (key) => [key, await distributed.get(key)]));
-            codes = new Map(results);
+        BUNDLE_RE.lastIndex = 0;
+        return refs;
+    };
+    const pending = bundlePaths.map((b) => ({ hash: b.hash }));
+    const seen = new Set();
+    const failed = new Set();
+    while (pending.length > 0) {
+        const batch = pending.splice(0, pending.length).filter((b) => !seen.has(b.hash));
+        if (batch.length === 0)
+            break;
+        for (const item of batch) {
+            seen.add(item.hash);
         }
-    }
-    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 = [];
-    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;
+        // 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;
         }
+        // Batch fetch from distributed cache
+        const codeKeys = missing.map((m) => `code:${m.hash}`);
+        let codes;
         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 });
+            if (distributed.getBatch) {
+                codes = await distributed.getBatch(codeKeys);
+            }
+            else {
+                const results = await Promise.all(codeKeys.map(async (key) => [key, await distributed.get(key)]));
+                codes = new Map(results);
+            }
         }
         catch (error) {
-            logger.error("[HTTP-CACHE] Failed to write bundle to disk", { hash, error });
-            failed.push(hash);
+            logger.error("[HTTP-CACHE] Batch fetch from distributed cache failed", { error });
+            for (const m of missing)
+                failed.add(m.hash);
+            continue;
         }
-    }));
-    if (failed.length > 0) {
-        logger.warn("[HTTP-CACHE] Some bundles could not be recovered", { failed });
+        // 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);
+            }
+        }));
     }
-    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);
 }

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/esm/src/utils/index.d.ts

@@ -3,7 +3,7 @@ export * from "./logger/index.js";
 export * from "./constants/index.js";
 export { VERSION } from "./version.js";
 export * from "./paths.js";
-export { type BundleCode as HashBundleCode, computeCodeHash, computeContentHash, computeHash, getContentHash, shortHash, simpleHash, simpleHash as numericHash, } from "./hash-utils.js";
+export { type BundleCode as HashBundleCode, computeCodeHash, computeContentHash, computeHash, getContentHash, shortHash, simpleHash, } from "./hash-utils.js";
 export { MemoCache, memoize, memoizeAsync, simpleHash as memoizeHash } from "./memoize.js";
 export * from "./path-utils.js";
 export * from "./format-utils.js";

package/esm/src/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,cAAc,YAAY,CAAC;AAE3B,OAAO,EACL,KAAK,UAAU,IAAI,cAAc,EACjC,eAAe,EACf,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,SAAS,EACT,UAAU,EACV,UAAU,IAAI,WAAW,GAC1B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3F,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,cAAc,YAAY,CAAC;AAE3B,OAAO,EACL,KAAK,UAAU,IAAI,cAAc,EACjC,eAAe,EACf,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,SAAS,EACT,UAAU,GACX,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3F,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC"}

package/esm/src/utils/index.js

@@ -3,7 +3,7 @@ export * from "./logger/index.js";
 export * from "./constants/index.js";
 export { VERSION } from "./version.js";
 export * from "./paths.js";
-export { computeCodeHash, computeContentHash, computeHash, getContentHash, shortHash, simpleHash, simpleHash as numericHash, } from "./hash-utils.js";
+export { computeCodeHash, computeContentHash, computeHash, getContentHash, shortHash, simpleHash, } from "./hash-utils.js";
 export { MemoCache, memoize, memoizeAsync, simpleHash as memoizeHash } from "./memoize.js";
 export * from "./path-utils.js";
 export * from "./format-utils.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.0.81",
+  "version": "0.0.83",
   "description": "Zero-config React meta-framework for building agentic AI applications",
   "keywords": [
     "react",
@@ -195,6 +195,7 @@
     "picocolors": "^1.1.0",
     "react": "19.1.1",
     "react-dom": "19.1.1",
+    "redis": "*",
     "rehype-highlight": "7.0.2",
     "rehype-slug": "6.0.0",
     "rehype-starry-night": "2.2.0",

package/src/deno.js

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

package/src/proxy/cache/index.ts

@@ -0,0 +1,93 @@
+/**
+ * Token Cache Module
+ *
+ * Provides configurable caching for OAuth tokens.
+ * Supports in-memory (single instance) and Redis (distributed) backends.
+ * Redis cache includes automatic fallback to memory when Redis is unavailable.
+ */
+
+export type {
+  CacheOptions,
+  CacheStats,
+  MemoryCacheOptions,
+  RedisCacheOptions,
+  TokenCache,
+  TokenCacheEntry,
+} from "./types.js";
+export { MemoryCache } from "./memory-cache.js";
+export { RedisCache } from "./redis-cache.js";
+export { ResilientCache } from "./resilient-cache.js";
+
+import type { CacheOptions, TokenCache } from "./types.js";
+import { MemoryCache } from "./memory-cache.js";
+import { RedisCache } from "./redis-cache.js";
+import { ResilientCache } from "./resilient-cache.js";
+import { getEnv } from "../../src/platform/compat/process.js";
+import { proxyLogger } from "../logger.js";
+import { withSpan } from "../tracing.js";
+
+const logger = proxyLogger.child({ module: "cache" });
+
+/**
+ * Create a token cache based on configuration.
+ *
+ * @example
+ * ```typescript
+ * // In-memory cache (default)
+ * const cache = createCache({ type: "memory" });
+ *
+ * // Redis cache for distributed deployments
+ * const cache = createCache({
+ *   type: "redis",
+ *   options: { url: "redis://localhost:6379" }
+ * });
+ * ```
+ */
+export async function createCache(options: CacheOptions): Promise<TokenCache> {
+  return withSpan("cache.create", async () => {
+    switch (options.type) {
+      case "redis":
+        return new RedisCache(options.options);
+      case "memory":
+      default:
+        return new MemoryCache(options.options);
+    }
+  }, { "cache.type": options.type });
+}
+
+/**
+ * Create cache from environment variables.
+ *
+ * Environment variables:
+ * - CACHE_TYPE: "memory" or "redis" (default: "memory")
+ * - REDIS_URL: Redis connection URL (required if CACHE_TYPE=redis)
+ * - REDIS_PREFIX: Key prefix (default: "vf:token:")
+ *
+ * When CACHE_TYPE=redis, automatically wraps with ResilientCache for
+ * graceful fallback to memory when Redis is unavailable.
+ */
+export async function createCacheFromEnv(): Promise<TokenCache> {
+  return withSpan("cache.createFromEnv", async () => {
+    const cacheType = getEnv("CACHE_TYPE") || "memory";
+
+    if (cacheType === "redis") {
+      const url = getEnv("REDIS_URL");
+      if (!url) {
+        logger.warn("[Cache] CACHE_TYPE=redis but REDIS_URL not set, falling back to memory");
+        return new MemoryCache();
+      }
+
+      const redisCache = new RedisCache({
+        url,
+        prefix: getEnv("REDIS_PREFIX") || "vf:token:",
+      });
+
+      // Wrap Redis with resilient fallback to memory cache
+      // This ensures the proxy continues to function when Redis is unavailable
+      logger.info("[Cache] Using Redis with memory fallback (ResilientCache)");
+      return new ResilientCache(redisCache, new MemoryCache());
+    }
+
+    return new MemoryCache();
+  }, { "cache.type": getEnv("CACHE_TYPE") || "memory" });
+}