veryfront 0.1.111 → 0.1.113

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

@@ -16,12 +16,19 @@ import { buildMdxEsmPathCacheKey, buildMdxEsmTransformCacheKey } from "../cache-
 export function getTransformCacheKey(
   projectId: string,
   contentSourceId: string,
+  reactVersion: string,
   normalizedPath: string,
   contentHash: string,
 ): string {
-  return buildMdxEsmTransformCacheKey(projectId, contentSourceId, normalizedPath, contentHash);
+  return buildMdxEsmTransformCacheKey(
+    projectId,
+    contentSourceId,
+    reactVersion,
+    normalizedPath,
+    contentHash,
+  );
 }
 
-export function getVersionedPathCacheKey(normalizedPath: string): string {
-  return buildMdxEsmPathCacheKey(normalizedPath);
+export function getVersionedPathCacheKey(normalizedPath: string, reactVersion: string): string {
+  return buildMdxEsmPathCacheKey(normalizedPath, reactVersion);
 }

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

@@ -8,12 +8,20 @@
  */
 
 import type { Logger } from "../../../../utils/logger/logger.js";
-import { getHttpBundleCacheDir, getMdxEsmCacheDir } from "../../../../utils/cache-dir.js";
+import {
+  extractAllFilePaths,
+  extractAllFilePathsRecursive,
+  extractAllHttpBundlePathsRecursive,
+  visitImportedVfModules,
+} from "../../../../modules/react-loader/ssr-module-loader/http-bundle-helpers.js";
+import {
+  getCacheBaseDir,
+  getHttpBundleCacheDir,
+  getMdxEsmCacheDir,
+} from "../../../../utils/cache-dir.js";
 import { FRAMEWORK_ROOT, LOG_PREFIX_MDX_LOADER } from "../constants.js";
 import { getLocalFs } from "../cache/index.js";
-import { extractHttpBundlePaths } from "../../../../modules/react-loader/ssr-module-loader/http-bundle-helpers.js";
 import { ensureHttpBundlesExist } from "../../../esm/http-cache.js";
-import { MDX_ESM_MJS_FILE_URL_PATTERN_SOURCE } from "../cache-format.js";
 import { ensureMdxModuleDependencies } from "./dependency-recovery.js";
 
 interface MdxRecoveryOptions {
@@ -21,47 +29,38 @@ interface MdxRecoveryOptions {
   contentSourceId: string;
 }
 
-/**
- * Check if cached code has file:// paths that are incompatible with this environment.
- * Returns true if the cached code should be invalidated (has paths from a different environment).
- *
- * Checks for:
- * 1. Framework source paths (file:///app/src/...) that don't match FRAMEWORK_ROOT
- * 2. HTTP bundle cache paths (file:///app/.cache/veryfront-http-bundle/...) that don't match local cache dir
- * 3. MDX ESM cache paths (file:///app/.cache/veryfront-mdx-esm/...) that don't match local cache dir
- *
- * IMPORTANT: This function creates a new RegExp on each call to avoid race conditions
- * when multiple modules are processed concurrently. Using a shared global regex with
- * the 'g' flag would cause interleaved exec() calls to skip paths.
- */
-export async function hasIncompatibleFrameworkPaths(code: string, log: Logger): Promise<boolean> {
-  // Check for esm.sh URLs that reference /_vf_modules/ paths - these are invalid
-  // and indicate a cached transform from before the fix was deployed
-  if (/esm\.sh\/_?vf_modules\//.test(code)) {
-    log.debug(`${LOG_PREFIX_MDX_LOADER} Cached code has invalid esm.sh/_vf_modules URL`);
-    return true;
-  }
+const INVALID_VFMOD_ESM_URL_PATTERN = /esm\.sh\/_?vf_modules\//;
 
-  const localHttpCacheDir = getHttpBundleCacheDir();
-  const localMdxCacheDir = getMdxEsmCacheDir();
+async function hasIncompatibleFrameworkPathsInCode(
+  code: string,
+  log: Logger,
+  options: {
+    localHttpCacheDir: string;
+    localMdxCacheDir: string;
+    localCacheBaseDir: string;
+    sourcePath?: string;
+  },
+): Promise<boolean> {
   const localFs = getLocalFs();
+  const sourceContext = options.sourcePath ? { vfModulePath: options.sourcePath } : {};
 
-  // Create a NEW regex for each call to avoid race conditions with concurrent calls.
-  // Global regexes maintain lastIndex state that can interleave between concurrent calls.
-  const allFilePathsPattern = /file:\/\/([^"'\s]+)/gi;
-
-  const allPaths: string[] = [];
-  let match: RegExpExecArray | null;
-  while ((match = allFilePathsPattern.exec(code)) !== null) {
-    if (match[1]) allPaths.push(match[1]);
+  if (INVALID_VFMOD_ESM_URL_PATTERN.test(code)) {
+    log.debug(
+      `${LOG_PREFIX_MDX_LOADER} Cached code has invalid esm.sh/_vf_modules URL`,
+      sourceContext,
+    );
+    return true;
   }
 
+  const allPaths = extractAllFilePaths(code);
+
   for (const path of allPaths) {
     if (path.includes("veryfront-http-bundle")) {
-      if (!path.startsWith(localHttpCacheDir)) {
+      if (!path.startsWith(options.localHttpCacheDir)) {
         log.debug(`${LOG_PREFIX_MDX_LOADER} HTTP bundle path from different environment`, {
           path,
-          expectedDir: localHttpCacheDir,
+          expectedDir: options.localHttpCacheDir,
+          ...sourceContext,
         });
         return true;
       }
@@ -69,22 +68,37 @@ export async function hasIncompatibleFrameworkPaths(code: string, log: Logger):
     }
 
     if (path.includes("veryfront-mdx-esm")) {
-      if (!path.startsWith(localMdxCacheDir)) {
+      if (!path.startsWith(options.localMdxCacheDir)) {
         log.debug(`${LOG_PREFIX_MDX_LOADER} MDX cache path from different environment`, {
           path,
-          expectedDir: localMdxCacheDir,
+          expectedDir: options.localMdxCacheDir,
+          ...sourceContext,
         });
         return true;
       }
       continue;
     }
 
+    // Legacy cache entries sometimes point directly at pod-local .cache source files
+    // like file:///app/.cache/markdown.tsx. These paths are not portable across pods.
+    // Allow local cache-base paths so valid local file:// dependencies under .cache
+    // are not evicted on every read.
+    if (path.includes(".cache/") && !path.startsWith(options.localCacheBaseDir)) {
+      log.debug(`${LOG_PREFIX_MDX_LOADER} Legacy cache path is not portable`, {
+        path,
+        expectedBaseDir: options.localCacheBaseDir,
+        ...sourceContext,
+      });
+      return true;
+    }
+
     if (!path.includes("/src/") || path.includes(".cache")) continue;
 
     if (!path.startsWith(FRAMEWORK_ROOT)) {
       log.debug(`${LOG_PREFIX_MDX_LOADER} Framework path from different environment`, {
         path,
         expectedRoot: FRAMEWORK_ROOT,
+        ...sourceContext,
       });
       return true;
     }
@@ -92,12 +106,18 @@ export async function hasIncompatibleFrameworkPaths(code: string, log: Logger):
     try {
       const stat = await localFs.stat(path);
       if (!stat?.isFile) {
-        log.debug(`${LOG_PREFIX_MDX_LOADER} Framework path does not exist`, { path });
+        log.debug(`${LOG_PREFIX_MDX_LOADER} Framework path does not exist`, {
+          path,
+          ...sourceContext,
+        });
         return true;
       }
     } catch (_) {
       /* expected: framework file may not exist in this environment */
-      log.debug(`${LOG_PREFIX_MDX_LOADER} Framework path not accessible`, { path });
+      log.debug(`${LOG_PREFIX_MDX_LOADER} Framework path not accessible`, {
+        path,
+        ...sourceContext,
+      });
       return true;
     }
   }
@@ -105,6 +125,42 @@ export async function hasIncompatibleFrameworkPaths(code: string, log: Logger):
   return false;
 }
 
+/**
+ * Check if cached code has file:// paths that are incompatible with this environment.
+ * Returns true if the cached code should be invalidated (has paths from a different environment).
+ *
+ * Checks for:
+ * 1. Framework source paths (file:///app/src/...) that don't match FRAMEWORK_ROOT
+ * 2. HTTP bundle cache paths (file:///app/.cache/veryfront-http-bundle/...) that don't match local cache dir
+ * 3. MDX ESM cache paths (file:///app/.cache/veryfront-mdx-esm/...) that don't match local cache dir
+ *
+ * This check also walks transitively imported VF modules so nested stale paths
+ * are rejected before import-time failures.
+ */
+export async function hasIncompatibleFrameworkPaths(code: string, log: Logger): Promise<boolean> {
+  const options = {
+    localHttpCacheDir: getHttpBundleCacheDir(),
+    localMdxCacheDir: getMdxEsmCacheDir(),
+    localCacheBaseDir: getCacheBaseDir(),
+  };
+
+  if (await hasIncompatibleFrameworkPathsInCode(code, log, options)) {
+    return true;
+  }
+
+  let incompatible = false;
+  await visitImportedVfModules(code, async (vfModuleCode, vfModulePath) => {
+    if (incompatible) return;
+
+    incompatible = await hasIncompatibleFrameworkPathsInCode(vfModuleCode, log, {
+      ...options,
+      sourcePath: vfModulePath,
+    });
+  });
+
+  return incompatible;
+}
+
 /**
  * Check if cached code has file:// paths that don't exist locally.
  * Returns list of missing paths, or empty array if all exist.
@@ -117,19 +173,10 @@ export async function findMissingFileDependenciesInCode(
   log: Logger,
 ): Promise<string[]> {
   const localFs = getLocalFs();
-  const pattern = new RegExp(MDX_ESM_MJS_FILE_URL_PATTERN_SOURCE, "gi");
   const missing: string[] = [];
-  const checked = new Set<string>();
-
-  let match;
-  while ((match = pattern.exec(code)) !== null) {
-    const path = match[1] as string;
-    // Skip query parameters in paths
-    const cleanPath = path.replace(/\?.*$/, "");
-
-    if (checked.has(cleanPath)) continue;
-    checked.add(cleanPath);
+  const allPaths = await extractAllFilePathsRecursive(code);
 
+  for (const cleanPath of allPaths) {
     try {
       const stat = await localFs.stat(cleanPath);
       if (!stat?.isFile) {
@@ -184,7 +231,7 @@ export async function validateCachedModule(
     return false;
   }
 
-  const bundlePaths = extractHttpBundlePaths(cachedCode);
+  const bundlePaths = await extractAllHttpBundlePathsRecursive(cachedCode);
   if (bundlePaths.length > 0) {
     const cacheDir = getHttpBundleCacheDir();
     const failed = await ensureHttpBundlesExist(bundlePaths, cacheDir);

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

@@ -19,6 +19,7 @@ import { transformToESM } from "../../../esm-transform.js";
 import { cacheHttpImportsToLocal } from "../../../esm/http-cache.js";
 import { loadImportMap } from "../../../../modules/import-map/index.js";
 import { getHttpBundleCacheDir } from "../../../../utils/cache-dir.js";
+import { REACT_DEFAULT_VERSION } from "../../../../utils/constants/cdn.js";
 import { LOG_PREFIX_MDX_LOADER } from "../constants.js";
 import type { ModuleFetcherContext } from "../types.js";
 import { getLocalFs, getModulePathCache } from "../cache/index.js";
@@ -191,9 +192,10 @@ async function doFetchAndCacheModule(
 ): Promise<string | null> {
   const log = getLog(context);
   const { esmCacheDir, adapter, projectDir, projectId, contentSourceId } = context;
+  const effectiveReactVersion = context.reactVersion ?? REACT_DEFAULT_VERSION;
 
   const pathCache = await getModulePathCache(esmCacheDir);
-  const versionedKey = getVersionedPathCacheKey(normalizedPath);
+  const versionedKey = getVersionedPathCacheKey(normalizedPath, effectiveReactVersion);
   const cachedPath = pathCache.get(versionedKey);
 
   if (cachedPath) {
@@ -241,7 +243,14 @@ async function doFetchAndCacheModule(
       );
 
       if (moduleCode) {
-        return await cacheModule(normalizedPath, moduleCode, esmCacheDir, pathCache, log);
+        return await cacheModule(
+          normalizedPath,
+          moduleCode,
+          esmCacheDir,
+          pathCache,
+          log,
+          effectiveReactVersion,
+        );
       }
 
       if (context.strictMissingModules ?? true) {
@@ -259,7 +268,13 @@ async function doFetchAndCacheModule(
 
     const contentHash = hashString(sourceCode);
     const transformCacheKey = contentSourceId
-      ? getTransformCacheKey(projectId, contentSourceId, normalizedPath, contentHash)
+      ? getTransformCacheKey(
+        projectId,
+        contentSourceId,
+        effectiveReactVersion,
+        normalizedPath,
+        contentHash,
+      )
       : null;
 
     let moduleCode: string | null = null;
@@ -276,7 +291,7 @@ async function doFetchAndCacheModule(
         normalizedPath,
         projectSlug,
         projectDir,
-        context.reactVersion,
+        effectiveReactVersion,
         log,
       )
       : null;
@@ -437,6 +452,7 @@ async function doFetchAndCacheModule(
       esmCacheDir,
       pathCache,
       log,
+      effectiveReactVersion,
     );
     log.debug(`${LOG_PREFIX_MDX_LOADER} [fetchAndCacheModule] cacheModule DONE`, {
       projectSlug,

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

@@ -10,6 +10,7 @@
 import { join } from "../../../../platform/compat/path/index.js";
 import * as posix from "../../../../../deps/jsr.io/@std/path/1.1.4/posix/mod.js";
 import type { Logger } from "../../../../utils/logger/logger.js";
+import { REACT_DEFAULT_VERSION } from "../../../../utils/constants/cdn.js";
 import { LOG_PREFIX_MDX_LOADER } from "../constants.js";
 import { getLocalFs, saveModulePathCache } from "../cache/index.js";
 import { hashString } from "../utils/hash.js";
@@ -48,6 +49,7 @@ export async function cacheModule(
   esmCacheDir: string,
   pathCache: Map<string, string>,
   log: Logger,
+  reactVersion = REACT_DEFAULT_VERSION,
 ): Promise<string | null> {
   const unresolved = hasUnresolvedImports(moduleCode);
   if (unresolved.count > 0) {
@@ -60,7 +62,7 @@ export async function cacheModule(
 
   const contentHash = hashString(normalizedPath + moduleCode);
   const cachePath = join(esmCacheDir, buildMdxEsmModuleFileName(contentHash));
-  const pathCacheKey = buildMdxEsmPathCacheKey(normalizedPath);
+  const pathCacheKey = buildMdxEsmPathCacheKey(normalizedPath, reactVersion);
 
   const localFs = getLocalFs();
   try {

package/src/src/utils/version.ts

@@ -3,7 +3,7 @@ import { getEnv } from "../platform/compat/process.js";
 
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.111";
+export const VERSION = "0.1.113";
 
 export function normalizeVeryfrontVersion(version: string | undefined): string | undefined {
   if (!version) return undefined;