veryfront 0.0.81 → 0.0.83

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 {

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

@@ -13,7 +13,12 @@ function getEnvString(key: string): string | undefined {
     Deno?: { env?: { get?: (k: string) => string | undefined } };
     process?: { env?: Record<string, string | undefined> };
   };
-  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: string, fallback: number): number {
@@ -158,3 +163,18 @@ export const TRANSFORM_DISTRIBUTED_TTL_SEC = getEnvNumber(
   "TRANSFORM_DISTRIBUTED_TTL_SEC",
   HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE, // 24 hours (86400)
 );
+
+// 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, // 5 minutes - short enough to pick up changes, long enough to cache
+);
+
+// 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, // 10 minutes - external modules change less frequently
+);

package/src/src/utils/index.ts

@@ -12,7 +12,6 @@ export {
   getContentHash,
   shortHash,
   simpleHash,
-  simpleHash as numericHash,
 } from "./hash-utils.js";
 
 export { MemoCache, memoize, memoizeAsync, simpleHash as memoizeHash } from "./memoize.js";