@ecopages/core 0.2.0-beta.8 → 0.2.0-rc.0

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

@@ -1,216 +1,242 @@
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import { fileSystem } from "@ecopages/file-system";
-import { build } from "../../build/build-adapter.js";
-import { normalizeNodeRuntimeBuildOutputFile } from "../../build/runtime-build-output-normalizer.js";
-import {
-  importPagesUnifiedGraphModule,
-  isPagesUnifiedGraphPage,
-  shouldBuildPagesUnifiedGraph
-} from "../../build/pages-unified-graph-build.js";
-import { recordPageModuleBuildInvocation } from "../../build/rolldown-build-invocation-metrics.js";
-import {
-  resolvePageModuleOutputFileName,
-  createPluginCacheKey,
-  createJsxCacheKey
-} from "./route-module-build-cache.js";
-import { getSharedRouteModuleBuildCache } from "./route-module-build-cache-registry.js";
-import { resolveRouteModuleDependencyPaths } from "./route-module-dependency-hasher.js";
-import { supportsSourceModuleLoading } from "./source-module-support.js";
-class PageModuleImportService {
-  appConfig;
-  dependencies;
-  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)
-    };
-  }
-  /**
-   * 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.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 { recordPageModuleLoad } from '../../diagnostics/request-pipeline-metrics.js';
+import { createRouteModuleReuseIdentity, resolvePageModuleOutputFileName } from './route-module-build-manifest.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();
+    developmentImportGeneration = 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) {
-      return await cachedModule;
+    /**
+     * Clears in-memory import promises and dependency-hash memoization so the next
+     * import revalidates against current source and transform identity.
+     */
+    invalidateDevelopmentGraph() {
+        this.developmentImportGeneration += 1;
+        this.clearImportCache();
+        this.dependencyHasher.clearMemo();
     }
-    const importPromise = this.loadModule({
-      ...options,
-      fileHash
-    });
-    this.importCache.set(cacheKey, 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 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, this.developmentImportGeneration);
+            const loadedModule = (await hostModuleLoader(sourceModuleUrl.href));
+            recordPageModuleLoad('host-loader');
+            return loadedModule;
+        }
+        if (!options.bypassCache) {
+            const runtime = typeof Bun !== 'undefined' ? 'bun' : 'node-build';
+            const cacheKey = [
+                runtime,
+                filePath,
+                createRouteModuleReuseIdentity(options, options.sourceTransforms),
+                fileHash,
+            ].join('::');
+            const cachedModule = this.importCache.get(cacheKey);
+            if (cachedModule) {
+                if (!cachedModule.dependencyHashes) {
+                    const loadedModule = (await cachedModule.promise);
+                    recordPageModuleLoad('import-cache-hit');
+                    return loadedModule;
+                }
+                if (this.dependencyHasher.matchesStoredHashes(cachedModule.dependencyHashes, filePath, fileHash)) {
+                    const loadedModule = (await cachedModule.promise);
+                    recordPageModuleLoad('import-cache-hit');
+                    return loadedModule;
+                }
+                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;
+            }
+        }
+        return await this.loadModule({
+            ...options,
+            fileHash,
+        });
     }
-  }
-  async loadModule(options) {
-    const { filePath, invalidationVersion = this.developmentInvalidationVersion, cacheScope, fileHash } = 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 routeModuleBuildCache = this.getRouteModuleBuildCache(outdir);
-    const cachedBuild = routeModuleBuildCache.lookup({
-      ...options,
-      fileHash
-    });
-    if (cachedBuild) {
-      return await import(
-        /* @vite-ignore */
-        pathToFileURL(cachedBuild.outputPath).href
-      );
+    async loadModule(options) {
+        const { filePath, 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 = createRuntimeBuildOutputFileName(resolvePageModuleOutputFileName({ filePath, fileHash }), this.developmentImportGeneration);
+        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,
+            sourceTransforms: buildOptions.sourceTransforms,
+            fileHash,
+        };
+        const routeModuleBuildCache = this.getRouteModuleBuildCache(outdir);
+        const cachedBuild = routeModuleBuildCache.lookup(cacheBuildOptions);
+        if (cachedBuild) {
+            const loadedModule = (await import(/* @vite-ignore */ pathToFileURL(cachedBuild.outputPath).href));
+            recordPageModuleLoad('disk-cache-hit');
+            return loadedModule;
+        }
+        if (shouldBuildPagesUnifiedGraph() && this.appConfig && isPagesUnifiedGraphPage(filePath, this.appConfig)) {
+            const graphModule = await importPagesUnifiedGraphModule(this.appConfig, filePath);
+            if (graphModule !== undefined) {
+                recordPageModuleLoad('unified-graph');
+                return graphModule;
+            }
+        }
+        recordPageModuleBuildInvocation();
+        const buildResult = await this.dependencies.buildModule(buildOptions, options.buildExecutor);
+        recordPageModuleLoad('cold-build', buildResult.outputs.length);
+        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()) {
+            compiledOutputUrl.searchParams.set('update', `${fileHash}-${this.developmentImportGeneration}`);
+        }
+        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(
-      {
-        entrypoints: [filePath],
-        root: rootDir,
-        outdir,
-        target: "es2022",
-        format: "esm",
-        sourcemap: "none",
-        splitting: splitting ?? true,
-        minify: false,
-        naming: outputNamingTemplate,
-        externalPackages: true,
-        jsx: options.jsx,
-        plugins: options.plugins,
-        ...externalPackages !== void 0 ? { externalPackages } : {}
-      },
-      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));
-    }
-    normalizeNodeRuntimeBuildOutputFile(compiledOutput, rootDir);
-    routeModuleBuildCache.recordBuild({
-      ...options,
-      fileHash,
-      outputPath: compiledOutput,
-      dependencyModulePaths: resolveRouteModuleDependencyPaths(buildResult, filePath, rootDir)
-    });
-    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;
+function createRuntimeModuleUrl(filePath, fileHash, developmentImportGeneration) {
+    const moduleUrl = pathToFileURL(filePath);
+    if (shouldAddRuntimeUpdateQuery()) {
+        moduleUrl.searchParams.set('update', `${fileHash}-${developmentImportGeneration}`);
+    }
+    return moduleUrl;
 }
-function shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope) {
-  return process.env.NODE_ENV === "development" || invalidationVersion > 0 || !!cacheScope;
+function shouldAddRuntimeUpdateQuery() {
+    return process.env.NODE_ENV === 'development';
 }
-function sanitizeCacheScope(cacheScope) {
-  return cacheScope.replace(/[^a-zA-Z0-9_-]+/g, "-");
+/**
+ * Gives Bun a distinct compiled module path after development invalidation.
+ *
+ * @remarks
+ * Bun does not reload an already-imported module when only its URL query changes.
+ * A dependency edit can leave the entrypoint source hash unchanged, so the output
+ * filename must include the import generation as well as the runtime query.
+ */
+function createRuntimeBuildOutputFileName(outputFileName, developmentImportGeneration) {
+    if (typeof Bun === 'undefined' || !shouldAddRuntimeUpdateQuery()) {
+        return outputFileName;
+    }
+    return outputFileName.replace(/\.mjs$/u, `-${developmentImportGeneration}.mjs`);
 }
-export {
-  PageModuleImportService
-};

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

@@ -22,3 +22,5 @@ export declare const getRouteModuleBuildCacheOutdir: typeof getServerModuleBuild
  * generation during the same build process.
  */
 export declare function getSharedRouteModuleBuildCache(outdir: string, appConfig?: EcoPagesAppConfig): RouteModuleBuildCache;
+/** Clears route-module cache entries that can retain stale external server modules during development. */
+export declare function clearAppDevelopmentRouteModuleBuildCaches(appConfig: EcoPagesAppConfig): void;

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

@@ -1,37 +1,63 @@
-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;
+}
+/** Clears route-module cache entries that can retain stale external server modules during development. */
+export function clearAppDevelopmentRouteModuleBuildCaches(appConfig) {
+    const serverModuleCacheOutdir = getServerModuleBuildCacheOutdir(appConfig);
+    const caches = appConfig.runtime?.routeModuleBuildCaches;
+    const serverModuleCache = caches?.get(serverModuleCacheOutdir) ?? new RouteModuleBuildCache(serverModuleCacheOutdir);
+    serverModuleCache.clearDevelopmentEntries();
+    for (const cache of caches?.values() ?? []) {
+        if (cache !== serverModuleCache) {
+            cache.clearDevelopmentEntries();
+        }
+    }
 }
-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';

package/src/services/module-loading/route-module-build-cache.store.d.ts

@@ -51,6 +51,16 @@ export declare class RouteModuleBuildCache {
         context: RouteModuleStaticRenderCacheContext;
     }): void;
     resetMemory(): void;
+    /**
+     * Removes every persisted route-module entry after development invalidation.
+     *
+     * @remarks
+     * Server bundles may externalize generated modules whose source dependencies
+     * are not present in the route bundle's dependency graph. Keeping an entry
+     * after its server graph changes can therefore reload a route that still
+     * imports an obsolete external bundle.
+     */
+    clearDevelopmentEntries(): void;
     pruneStaleRenderedOutputs(activePathnames: ReadonlySet<string>): string[];
     private loadManifest;
     private persistManifest;