@ecopages/core 0.2.0-beta.31 → 0.2.0-beta.32

package/src/services/module-loading/page-module-import.service.js

@@ -1,256 +1,248 @@
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { fileSystem } from "@ecopages/file-system";
-import { build } from "../../build/build-adapter.js";
-import { createServerBuildRequest } from "../../build/runtime/build-request-policy.js";
-import { resolveBuildProfileOptions } from "../../build/runtime/build-profile-options.js";
-import {
-  importPagesUnifiedGraphModule,
-  isPagesUnifiedGraphPage,
-  shouldBuildPagesUnifiedGraph
-} from "../../build/cache/pages-unified-graph-build.js";
-import { recordPageModuleBuildInvocation } from "../../build/rolldown/rolldown-build-invocation-metrics.js";
-import { resolvePageModuleOutputFileName } from "./route-module-build-cache.js";
-import { createPluginCacheKey, createJsxCacheKey } from "../../build/cache/cache-keys.js";
-import { getSharedRouteModuleBuildCache } from "./route-module-build-cache-registry.js";
-import {
-  RouteModuleDependencyHasher,
-  resolveRouteModuleDependencyPaths
-} from "./route-module-dependency-hasher.js";
-import { supportsSourceModuleLoading } from "./source-module-support.js";
-class PageModuleImportService {
-  appConfig;
-  dependencies;
-  dependencyHasher;
-  importCache = /* @__PURE__ */ new Map();
-  developmentInvalidationVersion = 0;
-  constructor(appConfig, dependencies) {
-    this.appConfig = appConfig;
-    this.dependencies = {
-      hashFile: dependencies?.hashFile ?? ((filePath) => fileSystem.hash(filePath)),
-      buildModule: dependencies?.buildModule ?? ((options, buildExecutor) => build(options, buildExecutor)),
-      canLoadSourceModuleFromHost: dependencies?.canLoadSourceModuleFromHost ?? supportsSourceModuleLoading,
-      getHostModuleLoader: dependencies?.getHostModuleLoader ?? (() => void 0)
-    };
-    this.dependencyHasher = new RouteModuleDependencyHasher({
-      hashFile: (filePath) => this.dependencies.hashFile(filePath),
-      exists: (filePath) => fileSystem.exists(filePath)
-    });
-  }
-  /**
-   * Clears the shared import cache used by framework-owned page-module loads.
-   */
-  clearImportCache() {
-    this.importCache.clear();
-  }
-  /**
-   * Invalidates all previously imported modules in development by clearing the
-   * import cache and incrementing the invalidation version included in cache keys.
-   *
-   * This forces all modules to be reloaded on the next import, even if their
-   * source content hasn't changed. This is necessary to ensure that changes to
-   * non-content aspects of modules (e.g. dependencies, transpilation output)
-   * are picked up during development.
-   */
-  invalidateDevelopmentGraph() {
-    this.clearImportCache();
-    this.dependencyHasher.clearMemo();
-    this.developmentInvalidationVersion += 1;
-  }
-  /**
-   * Imports a page-like module from source.
-   *
-   * The caller controls the output directory and error wording so different
-   * subsystems can reuse the same loading mechanism while preserving their
-   * current diagnostics. Module identities stay stable for unchanged files and
-   * roll forward automatically when the source hash changes during watch mode.
-   *
-   * @typeParam T Expected module shape.
-   * @param options Runtime-specific import settings.
-   * @returns The loaded module.
-   */
-  async importModule(options) {
-    const { filePath } = options;
-    const invalidationVersion = options.invalidationVersion ?? this.developmentInvalidationVersion;
-    const { externalPackages, splitting } = options;
-    const fileHash = this.dependencies.hashFile(filePath);
-    const hostModuleLoader = typeof Bun === "undefined" && process.env.NODE_ENV === "development" && this.dependencies.canLoadSourceModuleFromHost(filePath) ? this.dependencies.getHostModuleLoader() : void 0;
-    if (hostModuleLoader) {
-      const sourceModuleUrl = createRuntimeModuleUrl(filePath, fileHash, invalidationVersion, options.cacheScope);
-      return await hostModuleLoader(sourceModuleUrl.href);
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { fileSystem } from '@ecopages/file-system';
+import { build } from '../../build/build-adapter.js';
+import { createServerBuildRequest } from '../../build/runtime/build-request-policy.js';
+import { resolveBuildProfileOptions } from '../../build/runtime/build-profile-options.js';
+import { importPagesUnifiedGraphModule, isPagesUnifiedGraphPage, shouldBuildPagesUnifiedGraph, } from '../../build/cache/pages-unified-graph-build.js';
+import { recordPageModuleBuildInvocation } from '../../build/rolldown/rolldown-build-invocation-metrics.js';
+import { resolvePageModuleOutputFileName } from './route-module-build-cache.js';
+import { createPluginCacheKey, createJsxCacheKey } from '../../build/cache/cache-keys.js';
+import { getSharedRouteModuleBuildCache } from './route-module-build-cache-registry.js';
+import { RouteModuleDependencyHasher, resolveRouteModuleDependencyPaths, } from './route-module-dependency-hasher.js';
+import { supportsSourceModuleLoading } from './source-module-support.js';
+/**
+ * Loads page-like modules through the Ecopages build pipeline.
+ *
+ * This service centralizes the shared build-first import strategy used by route
+ * scanning, page data loading, and request-time page inspection. In Node
+ * development it can still delegate compatible source imports to the active
+ * host loader, but the public contract remains one transpile-targeted module
+ * loading path.
+ *
+ * Keeping this logic in one place prevents subtle drift in cache-busting,
+ * transpilation settings, and error semantics across the different callers.
+ */
+export class PageModuleImportService {
+    appConfig;
+    dependencies;
+    dependencyHasher;
+    importCache = new Map();
+    developmentInvalidationVersion = 0;
+    constructor(appConfig, dependencies) {
+        this.appConfig = appConfig;
+        this.dependencies = {
+            hashFile: dependencies?.hashFile ?? ((filePath) => fileSystem.hash(filePath)),
+            buildModule: dependencies?.buildModule ?? ((options, buildExecutor) => build(options, buildExecutor)),
+            canLoadSourceModuleFromHost: dependencies?.canLoadSourceModuleFromHost ?? supportsSourceModuleLoading,
+            getHostModuleLoader: dependencies?.getHostModuleLoader ?? (() => undefined),
+        };
+        this.dependencyHasher = new RouteModuleDependencyHasher({
+            hashFile: (filePath) => this.dependencies.hashFile(filePath),
+            exists: (filePath) => fileSystem.exists(filePath),
+        });
     }
-    if (options.bypassCache) {
-      this.developmentInvalidationVersion += 1;
-      return await this.loadModule({
-        ...options,
-        invalidationVersion: this.developmentInvalidationVersion,
-        fileHash
-      });
+    /**
+     * Clears the shared import cache used by framework-owned page-module loads.
+     */
+    clearImportCache() {
+        this.importCache.clear();
     }
-    const runtime = typeof Bun !== "undefined" ? "bun" : "node-build";
-    const cacheKey = [
-      runtime,
-      filePath,
-      options.rootDir,
-      path.resolve(options.outdir),
-      splitting ?? "default",
-      externalPackages ?? "default",
-      options.cacheScope ?? "default",
-      createJsxCacheKey(options.jsx),
-      createPluginCacheKey(options.plugins),
-      fileHash,
-      invalidationVersion
-    ].join("::");
-    const cachedModule = this.importCache.get(cacheKey);
-    if (cachedModule) {
-      if (!cachedModule.dependencyHashes) {
-        return await cachedModule.promise;
-      }
-      if (this.dependencyHasher.matchesStoredHashes(cachedModule.dependencyHashes, filePath, fileHash)) {
-        return await cachedModule.promise;
-      }
-      this.importCache.delete(cacheKey);
+    /**
+     * Invalidates all previously imported modules in development by clearing the
+     * import cache and incrementing the invalidation version included in cache keys.
+     *
+     * This forces all modules to be reloaded on the next import, even if their
+     * source content hasn't changed. This is necessary to ensure that changes to
+     * non-content aspects of modules (e.g. dependencies, transpilation output)
+     * are picked up during development.
+     */
+    invalidateDevelopmentGraph() {
+        this.clearImportCache();
+        this.dependencyHasher.clearMemo();
+        this.developmentInvalidationVersion += 1;
     }
-    const importPromise = this.loadModule({
-      ...options,
-      fileHash,
-      importCacheKey: cacheKey
-    });
-    this.importCache.set(cacheKey, { promise: importPromise });
-    try {
-      return await importPromise;
-    } catch (error) {
-      this.importCache.delete(cacheKey);
-      throw error;
+    /**
+     * Imports a page-like module from source.
+     *
+     * The caller controls the output directory and error wording so different
+     * subsystems can reuse the same loading mechanism while preserving their
+     * current diagnostics. Module identities stay stable for unchanged files and
+     * roll forward automatically when the source hash changes during watch mode.
+     *
+     * @typeParam T Expected module shape.
+     * @param options Runtime-specific import settings.
+     * @returns The loaded module.
+     */
+    async importModule(options) {
+        const { filePath } = options;
+        const invalidationVersion = options.invalidationVersion ?? this.developmentInvalidationVersion;
+        const { externalPackages, splitting } = options;
+        const fileHash = this.dependencies.hashFile(filePath);
+        const hostModuleLoader = typeof Bun === 'undefined' &&
+            process.env.NODE_ENV === 'development' &&
+            this.dependencies.canLoadSourceModuleFromHost(filePath)
+            ? this.dependencies.getHostModuleLoader()
+            : undefined;
+        if (hostModuleLoader) {
+            const sourceModuleUrl = createRuntimeModuleUrl(filePath, fileHash, invalidationVersion, options.cacheScope);
+            return (await hostModuleLoader(sourceModuleUrl.href));
+        }
+        if (options.bypassCache) {
+            this.developmentInvalidationVersion += 1;
+            return await this.loadModule({
+                ...options,
+                invalidationVersion: this.developmentInvalidationVersion,
+                fileHash,
+            });
+        }
+        const runtime = typeof Bun !== 'undefined' ? 'bun' : 'node-build';
+        const cacheKey = [
+            runtime,
+            filePath,
+            options.rootDir,
+            path.resolve(options.outdir),
+            splitting ?? 'default',
+            externalPackages ?? 'default',
+            options.cacheScope ?? 'default',
+            createJsxCacheKey(options.jsx),
+            createPluginCacheKey(options.plugins),
+            fileHash,
+            invalidationVersion,
+        ].join('::');
+        const cachedModule = this.importCache.get(cacheKey);
+        if (cachedModule) {
+            if (!cachedModule.dependencyHashes) {
+                return (await cachedModule.promise);
+            }
+            if (this.dependencyHasher.matchesStoredHashes(cachedModule.dependencyHashes, filePath, fileHash)) {
+                return (await cachedModule.promise);
+            }
+            this.importCache.delete(cacheKey);
+        }
+        const importPromise = this.loadModule({
+            ...options,
+            fileHash,
+            importCacheKey: cacheKey,
+        });
+        this.importCache.set(cacheKey, { promise: importPromise });
+        try {
+            return await importPromise;
+        }
+        catch (error) {
+            this.importCache.delete(cacheKey);
+            throw error;
+        }
     }
-  }
-  async loadModule(options) {
-    const {
-      filePath,
-      invalidationVersion = this.developmentInvalidationVersion,
-      cacheScope,
-      fileHash,
-      importCacheKey
-    } = options;
-    const {
-      rootDir,
-      outdir,
-      splitting,
-      externalPackages,
-      transpileErrorMessage = (details) => `Error transpiling page module: ${details}`,
-      noOutputMessage = (targetFilePath) => `No transpiled output generated for page module: ${targetFilePath}`
-    } = options;
-    const outputFileName = resolvePageModuleOutputFileName({
-      filePath,
-      fileHash,
-      cacheScope,
-      invalidationVersion
-    });
-    const outputNamingTemplate = outputFileName.replace(/\.mjs$/u, ".[ext]");
-    const preferredOutputPath = path.join(outdir, outputFileName);
-    const buildOptions = this.appConfig ? createServerBuildRequest(this.appConfig, {
-      profile: "route-module",
-      entrypoints: [filePath],
-      outdir,
-      naming: outputNamingTemplate,
-      splitting: splitting ?? true,
-      jsx: options.jsx,
-      plugins: options.plugins,
-      root: rootDir,
-      ...externalPackages !== void 0 ? { externalPackages } : {}
-    }) : {
-      ...resolveBuildProfileOptions("route-module", { rootDir }, {
-        entrypoints: [filePath],
-        outdir,
-        naming: outputNamingTemplate,
-        splitting: splitting ?? true,
-        jsx: options.jsx,
-        plugins: options.plugins,
-        ...externalPackages !== void 0 ? { externalPackages } : {}
-      }),
-      root: rootDir,
-      entrypoints: [filePath]
-    };
-    const cacheBuildOptions = {
-      ...options,
-      rootDir: buildOptions.root ?? rootDir,
-      outdir: buildOptions.outdir ?? outdir,
-      splitting: buildOptions.splitting,
-      externalPackages: buildOptions.externalPackages,
-      jsx: buildOptions.jsx,
-      plugins: buildOptions.plugins,
-      fileHash
-    };
-    const routeModuleBuildCache = this.getRouteModuleBuildCache(outdir);
-    const cachedBuild = routeModuleBuildCache.lookup(cacheBuildOptions);
-    if (cachedBuild) {
-      return await import(
-        /* @vite-ignore */
-        pathToFileURL(cachedBuild.outputPath).href
-      );
+    async loadModule(options) {
+        const { filePath, invalidationVersion = this.developmentInvalidationVersion, cacheScope, fileHash, importCacheKey, } = options;
+        const { rootDir, outdir, splitting, externalPackages, transpileErrorMessage = (details) => `Error transpiling page module: ${details}`, noOutputMessage = (targetFilePath) => `No transpiled output generated for page module: ${targetFilePath}`, } = options;
+        const outputFileName = resolvePageModuleOutputFileName({
+            filePath,
+            fileHash,
+            cacheScope,
+            invalidationVersion,
+        });
+        const outputNamingTemplate = outputFileName.replace(/\.mjs$/u, '.[ext]');
+        const preferredOutputPath = path.join(outdir, outputFileName);
+        const buildOptions = this.appConfig
+            ? createServerBuildRequest(this.appConfig, {
+                profile: 'route-module',
+                entrypoints: [filePath],
+                outdir,
+                naming: outputNamingTemplate,
+                splitting: splitting ?? true,
+                jsx: options.jsx,
+                plugins: options.plugins,
+                root: rootDir,
+                ...(externalPackages !== undefined ? { externalPackages } : {}),
+            })
+            : {
+                ...resolveBuildProfileOptions('route-module', { rootDir }, {
+                    entrypoints: [filePath],
+                    outdir,
+                    naming: outputNamingTemplate,
+                    splitting: splitting ?? true,
+                    jsx: options.jsx,
+                    plugins: options.plugins,
+                    ...(externalPackages !== undefined ? { externalPackages } : {}),
+                }),
+                root: rootDir,
+                entrypoints: [filePath],
+            };
+        const cacheBuildOptions = {
+            ...options,
+            rootDir: buildOptions.root ?? rootDir,
+            outdir: buildOptions.outdir ?? outdir,
+            splitting: buildOptions.splitting,
+            externalPackages: buildOptions.externalPackages,
+            jsx: buildOptions.jsx,
+            plugins: buildOptions.plugins,
+            fileHash,
+        };
+        const routeModuleBuildCache = this.getRouteModuleBuildCache(outdir);
+        const cachedBuild = routeModuleBuildCache.lookup(cacheBuildOptions);
+        if (cachedBuild) {
+            return (await import(/* @vite-ignore */ pathToFileURL(cachedBuild.outputPath).href));
+        }
+        if (!cacheScope &&
+            shouldBuildPagesUnifiedGraph() &&
+            this.appConfig &&
+            isPagesUnifiedGraphPage(filePath, this.appConfig)) {
+            const graphModule = await importPagesUnifiedGraphModule(this.appConfig, filePath);
+            if (graphModule !== undefined) {
+                return graphModule;
+            }
+        }
+        recordPageModuleBuildInvocation();
+        const buildResult = await this.dependencies.buildModule(buildOptions, options.buildExecutor);
+        if (!buildResult.success) {
+            const details = buildResult.logs.map((log) => log.message).join(' | ');
+            throw new Error(transpileErrorMessage(details));
+        }
+        const compiledOutput = buildResult.outputs.find((output) => output.path === preferredOutputPath)?.path ??
+            buildResult.outputs.find((output) => /\.(?:[cm]?js)$/u.test(output.path))?.path;
+        if (!compiledOutput) {
+            throw new Error(noOutputMessage(filePath));
+        }
+        const dependencyModulePaths = resolveRouteModuleDependencyPaths(buildResult, filePath, rootDir);
+        const dependencyHashes = this.dependencyHasher.createDependencyHashes(dependencyModulePaths);
+        dependencyHashes[path.normalize(filePath)] = fileHash;
+        if (importCacheKey) {
+            const cacheEntry = this.importCache.get(importCacheKey);
+            if (cacheEntry) {
+                cacheEntry.dependencyHashes = dependencyHashes;
+            }
+        }
+        routeModuleBuildCache.recordBuild({
+            ...cacheBuildOptions,
+            outputPath: compiledOutput,
+            dependencyModulePaths,
+        });
+        const compiledOutputUrl = pathToFileURL(compiledOutput);
+        if (shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope)) {
+            compiledOutputUrl.searchParams.set('update', [fileHash, invalidationVersion, cacheScope ? sanitizeCacheScope(cacheScope) : undefined]
+                .filter((value) => value !== undefined)
+                .join('-'));
+        }
+        return (await import(/* @vite-ignore */ compiledOutputUrl.href));
     }
-    if (!cacheScope && shouldBuildPagesUnifiedGraph() && this.appConfig && isPagesUnifiedGraphPage(filePath, this.appConfig)) {
-      const graphModule = await importPagesUnifiedGraphModule(this.appConfig, filePath);
-      if (graphModule !== void 0) {
-        return graphModule;
-      }
+    getRouteModuleBuildCache(outdir) {
+        return getSharedRouteModuleBuildCache(outdir, this.appConfig);
     }
-    recordPageModuleBuildInvocation();
-    const buildResult = await this.dependencies.buildModule(buildOptions, options.buildExecutor);
-    if (!buildResult.success) {
-      const details = buildResult.logs.map((log) => log.message).join(" | ");
-      throw new Error(transpileErrorMessage(details));
-    }
-    const compiledOutput = buildResult.outputs.find((output) => output.path === preferredOutputPath)?.path ?? buildResult.outputs.find((output) => /\.(?:[cm]?js)$/u.test(output.path))?.path;
-    if (!compiledOutput) {
-      throw new Error(noOutputMessage(filePath));
-    }
-    const dependencyModulePaths = resolveRouteModuleDependencyPaths(buildResult, filePath, rootDir);
-    const dependencyHashes = this.dependencyHasher.createDependencyHashes(dependencyModulePaths);
-    dependencyHashes[path.normalize(filePath)] = fileHash;
-    if (importCacheKey) {
-      const cacheEntry = this.importCache.get(importCacheKey);
-      if (cacheEntry) {
-        cacheEntry.dependencyHashes = dependencyHashes;
-      }
-    }
-    routeModuleBuildCache.recordBuild({
-      ...cacheBuildOptions,
-      outputPath: compiledOutput,
-      dependencyModulePaths
-    });
-    const compiledOutputUrl = pathToFileURL(compiledOutput);
-    if (shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope)) {
-      compiledOutputUrl.searchParams.set(
-        "update",
-        [fileHash, invalidationVersion, cacheScope ? sanitizeCacheScope(cacheScope) : void 0].filter((value) => value !== void 0).join("-")
-      );
-    }
-    return await import(
-      /* @vite-ignore */
-      compiledOutputUrl.href
-    );
-  }
-  getRouteModuleBuildCache(outdir) {
-    return getSharedRouteModuleBuildCache(outdir, this.appConfig);
-  }
 }
 function createRuntimeModuleUrl(filePath, fileHash, invalidationVersion, cacheScope) {
-  const moduleUrl = pathToFileURL(filePath);
-  if (shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope)) {
-    moduleUrl.searchParams.set(
-      "update",
-      [fileHash, invalidationVersion, cacheScope ? sanitizeCacheScope(cacheScope) : void 0].filter((value) => value !== void 0).join("-")
-    );
-  }
-  return moduleUrl;
+    const moduleUrl = pathToFileURL(filePath);
+    if (shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope)) {
+        moduleUrl.searchParams.set('update', [fileHash, invalidationVersion, cacheScope ? sanitizeCacheScope(cacheScope) : undefined]
+            .filter((value) => value !== undefined)
+            .join('-'));
+    }
+    return moduleUrl;
 }
 function shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope) {
-  return process.env.NODE_ENV === "development" || invalidationVersion > 0 || !!cacheScope;
+    return process.env.NODE_ENV === 'development' || invalidationVersion > 0 || !!cacheScope;
 }
 function sanitizeCacheScope(cacheScope) {
-  return cacheScope.replace(/[^a-zA-Z0-9_-]+/g, "-");
+    return cacheScope.replace(/[^a-zA-Z0-9_-]+/g, '-');
 }
-export {
-  PageModuleImportService
-};

package/src/services/module-loading/route-module-build-cache-registry.js

@@ -1,37 +1,51 @@
-import path from "node:path";
-import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
-import { RouteModuleBuildCache } from "./route-module-build-cache.store.js";
-function getServerModuleBuildCacheOutdir(appConfig) {
-  return path.join(resolveInternalExecutionDir(appConfig), ".server-modules");
+import path from 'node:path';
+import { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.js';
+import { RouteModuleBuildCache } from './route-module-build-cache.store.js';
+/**
+ * Returns the outdir whose transpile cache backs incremental static generation.
+ *
+ * @remarks
+ * Static pages render through `.eco/.server-modules`. The manifest there carries
+ * import-graph hashes from transpile, so static-render reuse must read the same
+ * directory rather than `.server-route-modules`, which only serves route-registry
+ * scanning.
+ */
+export function getServerModuleBuildCacheOutdir(appConfig) {
+    return path.join(resolveInternalExecutionDir(appConfig), '.server-modules');
 }
-const getRouteModuleBuildCacheOutdir = getServerModuleBuildCacheOutdir;
+/**
+ * @deprecated Use {@link getServerModuleBuildCacheOutdir}.
+ */
+export const getRouteModuleBuildCacheOutdir = getServerModuleBuildCacheOutdir;
 function getRouteModuleBuildCacheMap(appConfig) {
-  const existing = appConfig.runtime?.routeModuleBuildCaches;
-  if (existing) {
-    return existing;
-  }
-  const routeModuleBuildCaches = /* @__PURE__ */ new Map();
-  appConfig.runtime = {
-    ...appConfig.runtime ?? {},
-    routeModuleBuildCaches
-  };
-  return routeModuleBuildCaches;
+    const existing = appConfig.runtime?.routeModuleBuildCaches;
+    if (existing) {
+        return existing;
+    }
+    const routeModuleBuildCaches = new Map();
+    appConfig.runtime = {
+        ...(appConfig.runtime ?? {}),
+        routeModuleBuildCaches,
+    };
+    return routeModuleBuildCaches;
 }
-function getSharedRouteModuleBuildCache(outdir, appConfig) {
-  if (!appConfig) {
-    return new RouteModuleBuildCache(outdir);
-  }
-  const caches = getRouteModuleBuildCacheMap(appConfig);
-  const existingCache = caches.get(outdir);
-  if (existingCache) {
-    return existingCache;
-  }
-  const routeModuleBuildCache = new RouteModuleBuildCache(outdir);
-  caches.set(outdir, routeModuleBuildCache);
-  return routeModuleBuildCache;
+/**
+ * Returns the shared production build cache for one server-module outdir.
+ *
+ * @remarks
+ * One app-scoped instance prevents manifest drift between page imports and static
+ * generation during the same build process.
+ */
+export function getSharedRouteModuleBuildCache(outdir, appConfig) {
+    if (!appConfig) {
+        return new RouteModuleBuildCache(outdir);
+    }
+    const caches = getRouteModuleBuildCacheMap(appConfig);
+    const existingCache = caches.get(outdir);
+    if (existingCache) {
+        return existingCache;
+    }
+    const routeModuleBuildCache = new RouteModuleBuildCache(outdir);
+    caches.set(outdir, routeModuleBuildCache);
+    return routeModuleBuildCache;
 }
-export {
-  getRouteModuleBuildCacheOutdir,
-  getServerModuleBuildCacheOutdir,
-  getSharedRouteModuleBuildCache
-};

package/src/services/module-loading/route-module-build-cache.js

@@ -1,38 +1,3 @@
-import {
-  ROUTE_MODULE_BUILD_CACHE_FILENAME,
-  createEmptyRouteModuleBuildCacheManifest,
-  createPersistedRouteModuleBuildKey,
-  createPluginCacheKey,
-  createJsxCacheKey,
-  hashPluginSetup,
-  getCorePackageVersion,
-  normalizeRouteModuleCachePath,
-  readRouteModuleBuildCacheManifest,
-  resolvePageModuleOutputFileName,
-  shouldPersistRouteModuleBuildCache,
-  writeRouteModuleBuildCacheManifest
-} from "./route-module-build-manifest.js";
-import { RouteModuleBuildCache } from "./route-module-build-cache.store.js";
-import {
-  getRouteModuleBuildCacheOutdir,
-  getServerModuleBuildCacheOutdir,
-  getSharedRouteModuleBuildCache
-} from "./route-module-build-cache-registry.js";
-export {
-  ROUTE_MODULE_BUILD_CACHE_FILENAME,
-  RouteModuleBuildCache,
-  createEmptyRouteModuleBuildCacheManifest,
-  createJsxCacheKey,
-  createPersistedRouteModuleBuildKey,
-  createPluginCacheKey,
-  getCorePackageVersion,
-  getRouteModuleBuildCacheOutdir,
-  getServerModuleBuildCacheOutdir,
-  getSharedRouteModuleBuildCache,
-  hashPluginSetup,
-  normalizeRouteModuleCachePath,
-  readRouteModuleBuildCacheManifest,
-  resolvePageModuleOutputFileName,
-  shouldPersistRouteModuleBuildCache,
-  writeRouteModuleBuildCacheManifest
-};
+export { ROUTE_MODULE_BUILD_CACHE_FILENAME, createEmptyRouteModuleBuildCacheManifest, createPersistedRouteModuleBuildKey, createPluginCacheKey, createJsxCacheKey, hashPluginSetup, getCorePackageVersion, normalizeRouteModuleCachePath, readRouteModuleBuildCacheManifest, resolvePageModuleOutputFileName, shouldPersistRouteModuleBuildCache, writeRouteModuleBuildCacheManifest, } from './route-module-build-manifest.js';
+export { RouteModuleBuildCache } from './route-module-build-cache.store.js';
+export { getRouteModuleBuildCacheOutdir, getServerModuleBuildCacheOutdir, getSharedRouteModuleBuildCache, } from './route-module-build-cache-registry.js';