@ecopages/core 0.2.0-beta.2 → 0.2.0-beta.20

package/src/services/assets/asset-processing-service/processors/stylesheet/file-stylesheet.processor.js

@@ -1,43 +1,15 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
 import { BaseProcessor } from "../base/base-processor.js";
+import { applyStylesheetProcessors } from "./stylesheet-processor-pipeline.js";
 class FileStylesheetProcessor extends BaseProcessor {
-  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
   getStyleContent = (srcUrl) => {
     return fileSystem.readFileAsBuffer(srcUrl);
   };
-  isProcessableStylesheet(filepath) {
-    return FileStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
-  }
-  async applyStylesheetProcessors(content, filepath) {
-    if (!this.isProcessableStylesheet(filepath)) {
-      return content;
-    }
-    let transformedContent = content;
-    for (const processor of this.appConfig.processors.values()) {
-      const hasCapabilities = processor.getAssetCapabilities().length > 0;
-      const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
-      if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes("postcss"))) {
-        continue;
-      }
-      if (!processor.matchesFileFilter(filepath)) {
-        continue;
-      }
-      const result = await processor.process(transformedContent, filepath);
-      if (typeof result === "string") {
-        transformedContent = result;
-        continue;
-      }
-      if (result instanceof Buffer) {
-        transformedContent = result.toString();
-      }
-    }
-    return transformedContent;
-  }
   async process(dep) {
     const buffer = this.getStyleContent(dep.filepath);
     const rawContent = buffer.toString();
-    const processedContent = await this.applyStylesheetProcessors(rawContent, dep.filepath);
+    const processedContent = await applyStylesheetProcessors(this.appConfig, rawContent, dep.filepath);
     const hash = this.generateHash(processedContent);
     const cachekey = this.buildCacheKey(dep.filepath, hash, dep);
     return this.getOrProcess(cachekey, () => {

package/src/services/assets/asset-processing-service/processors/stylesheet/stylesheet-processor-pipeline.d.ts

@@ -0,0 +1,2 @@
+import type { EcoPagesAppConfig } from '../../../../../types/internal-types.js';
+export declare function applyStylesheetProcessors(appConfig: EcoPagesAppConfig, content: string, filepath: string): Promise<string>;

package/src/services/assets/asset-processing-service/processors/stylesheet/stylesheet-processor-pipeline.js

@@ -0,0 +1,43 @@
+import path from "node:path";
+const PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
+function isProcessableStylesheet(filepath) {
+  return PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
+}
+function shouldRunStylesheetProcessor(processor, filepath) {
+  const hasCapabilities = processor.getAssetCapabilities().length > 0;
+  const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
+  if (canProcessStylesheet) {
+    return true;
+  }
+  if (hasCapabilities) {
+    return false;
+  }
+  return processor.getName().includes("postcss");
+}
+async function applyStylesheetProcessors(appConfig, content, filepath) {
+  if (!isProcessableStylesheet(filepath)) {
+    return content;
+  }
+  let transformedContent = content;
+  const processors = appConfig.processors ? Array.from(appConfig.processors.values()) : [];
+  for (const processor of processors) {
+    if (!shouldRunStylesheetProcessor(processor, filepath)) {
+      continue;
+    }
+    if (!processor.matchesFileFilter(filepath)) {
+      continue;
+    }
+    const result = await processor.process(transformedContent, filepath);
+    if (typeof result === "string") {
+      transformedContent = result;
+      continue;
+    }
+    if (result instanceof Buffer) {
+      transformedContent = result.toString();
+    }
+  }
+  return transformedContent;
+}
+export {
+  applyStylesheetProcessors
+};

package/src/services/assets/browser-bundle.service.d.ts

@@ -16,6 +16,7 @@ export type BrowserBundleOptions = {
     externalPackages?: boolean;
     external?: string[];
     plugins?: EcoBuildPlugin[];
+    executor?: 'build' | 'hmr';
     [key: string]: unknown;
     profile: BuildTranspileProfile;
     excludeAppBuildPlugins?: string[];
@@ -65,7 +66,8 @@ export declare class BrowserBundleService implements BrowserBundleExecutor {
      * @remarks
      * Browser defaults and app-owned browser build plugins are applied here so HMR
      * and runtime asset generation do not have to recreate that policy at each call
-     * site.
+     * site. Also forwards {@link getAppSourceTransforms | app source transforms} so
+     * metadata injection runs after boundary/runtime `onLoad` rewrites.
      */
     bundle(options: BrowserBundleOptions): Promise<BuildResult>;
     bundleGroupedEntries(entries: BrowserBundleGroupedEntry[], options: BrowserBundleGroupedOptions): Promise<BuildResult>;

package/src/services/assets/browser-bundle.service.js

@@ -1,5 +1,14 @@
-import { getAppBrowserBuildPlugins, getAppBuildExecutor, getAppTranspileOptions } from "../../build/build-adapter.js";
+import { getAppBrowserBuildPlugins, getAppTranspileOptions } from "../../build/build-adapter.js";
+import { requireBuildRuntime } from "../../build/build-runtime.js";
 import { mergeEcoBuildPlugins } from "../../build/build-manifest.js";
+import { getAppSourceTransforms } from "../../plugins/source-transform.js";
+function resolveBrowserBundleExecutor(appConfig, profile, executor) {
+  const buildRuntime = requireBuildRuntime(appConfig);
+  if (executor === "hmr" && profile === "hmr-entrypoint") {
+    return buildRuntime.getProfile("browser-hmr");
+  }
+  return buildRuntime.getProfile("route-module");
+}
 class BrowserBundleService {
   appConfig;
   /**
@@ -14,19 +23,22 @@ class BrowserBundleService {
    * @remarks
    * Browser defaults and app-owned browser build plugins are applied here so HMR
    * and runtime asset generation do not have to recreate that policy at each call
-   * site.
+   * site. Also forwards {@link getAppSourceTransforms | app source transforms} so
+   * metadata injection runs after boundary/runtime `onLoad` rewrites.
    */
   async bundle(options) {
-    const { profile, excludeAppBuildPlugins, plugins, ...rawBuildOptions } = options;
+    const { profile, excludeAppBuildPlugins, plugins, executor = "hmr", ...rawBuildOptions } = options;
     const appBrowserPlugins = getAppBrowserBuildPlugins(this.appConfig);
     const filteredAppBrowserPlugins = excludeAppBuildPlugins && excludeAppBuildPlugins.length > 0 ? appBrowserPlugins.filter((plugin) => !excludeAppBuildPlugins.includes(plugin.name)) : appBrowserPlugins;
     const request = {
       ...rawBuildOptions,
       entrypoints: options.entrypoints,
       ...getAppTranspileOptions(this.appConfig, profile),
-      plugins: mergeEcoBuildPlugins(plugins, filteredAppBrowserPlugins)
+      plugins: mergeEcoBuildPlugins(plugins, filteredAppBrowserPlugins),
+      sourceTransforms: getAppSourceTransforms(this.appConfig)
     };
-    return await getAppBuildExecutor(this.appConfig).build(request);
+    const buildExecutor = resolveBrowserBundleExecutor(this.appConfig, profile, executor);
+    return await buildExecutor.build(request);
   }
   async bundleGroupedEntries(entries, options) {
     const request = {

package/src/services/html/html-transformer.service.d.ts

@@ -83,7 +83,7 @@ export declare class HtmlTransformerService {
      * string-based fallback remains in place for runtimes that cannot provide one
      * of those rewriter implementations.
      */
-    transform(res: Response, contributions?: HtmlDocumentContribution[]): Promise<Response>;
+    transform(res: Response, contributions?: HtmlDocumentContribution[], pagePackage?: PagePackageResult): Promise<Response>;
     /**
      * Splits processed assets into head and body injection groups.
      */

package/src/services/html/html-transformer.service.js

@@ -188,8 +188,8 @@ class HtmlTransformerService {
    * string-based fallback remains in place for runtimes that cannot provide one
    * of those rewriter implementations.
    */
-  async transform(res, contributions = []) {
-    const { head, body } = this.groupDependenciesByPosition();
+  async transform(res, contributions = [], pagePackage) {
+    const { head, body } = this.groupDependenciesByPosition(pagePackage);
     const { headPrepend, headAppend, bodyPrepend, bodyAppend } = this.groupContributionsByPlacement(contributions);
     const htmlRewriter = await this.htmlRewriterProvider.createHtmlRewriter();
     if (htmlRewriter) {
@@ -239,8 +239,8 @@ class HtmlTransformerService {
   /**
    * Splits processed assets into head and body injection groups.
    */
-  groupDependenciesByPosition() {
-    const dependencies = this.pagePackage ? this.resolvePagePackageHtmlDependencies(this.pagePackage) : this.processedDependencies;
+  groupDependenciesByPosition(pagePackageOverride) {
+    const dependencies = pagePackageOverride ? this.resolvePagePackageHtmlDependencies(pagePackageOverride) : this.pagePackage ? this.resolvePagePackageHtmlDependencies(this.pagePackage) : this.processedDependencies;
     return dependencies.reduce(
       (acc, dep) => {
         if (dep.kind === "script") {

package/src/services/invalidation/development-invalidation.service.d.ts

@@ -1,5 +1,6 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-export type DevelopmentInvalidationCategory = 'public-asset' | 'additional-watch' | 'include-source' | 'route-source' | 'processor-owned-asset' | 'server-source' | 'other';
+import type { EcoPagesAppConfig, RegisteredScriptEntrypointChangeHandler } from '../../types/internal-types.js';
+export type { RegisteredScriptEntrypointChangeHandler };
+export type DevelopmentInvalidationCategory = 'public-asset' | 'additional-watch' | 'include-source' | 'explicit-server-view' | 'route-source' | 'processor-owned-asset' | 'server-source' | 'other';
 /**
  * Framework-owned invalidation plan for one changed file.
  *
@@ -38,6 +39,14 @@ export declare class DevelopmentInvalidationService {
      * Invalidates the app-owned server-module graph.
      */
     invalidateServerModules(changedFiles?: string[]): void;
+    /**
+     * Registers an integration-owned handler for registered script entrypoint edits.
+     */
+    registerRegisteredScriptEntrypointChangeHandler(handler: RegisteredScriptEntrypointChangeHandler): void;
+    /**
+     * Notifies integration handlers that a registered script entrypoint changed.
+     */
+    notifyRegisteredScriptEntrypointChange(filePath: string): Promise<void>;
     /**
      * Resets runtime-owned graph state and invalidates server modules.
      */
@@ -62,6 +71,15 @@ export declare class DevelopmentInvalidationService {
      * Returns whether the file is an include/template source file.
      */
     isIncludeSourceFile(filePath: string): boolean;
+    /**
+     * Returns whether the file is an explicit server-rendered view module.
+     *
+     * @remarks
+     * These modules are typically registered through `renderServerModule` in
+     * `app.ts` rather than the filesystem router. They need a full browser reload
+     * because their HTML is produced on the server, not through client HMR entrypoints.
+     */
+    isExplicitServerViewFile(filePath: string): boolean;
     /**
      * Returns whether the file is a server-executed source module outside the
      * special route/include buckets.

package/src/services/invalidation/development-invalidation.service.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { getAppServerInvalidationState } from "../runtime-state/server-invalidation-state.service.js";
+import { appLogger } from "../../global/app-logger.js";
 class DevelopmentInvalidationService {
   appConfig;
   constructor(appConfig) {
@@ -18,6 +19,30 @@ class DevelopmentInvalidationService {
     getAppServerInvalidationState(this.appConfig).invalidateServerModules(changedFiles);
     this.appConfig.runtime?.appModuleLoader?.invalidateDevelopmentGraph();
   }
+  /**
+   * Registers an integration-owned handler for registered script entrypoint edits.
+   */
+  registerRegisteredScriptEntrypointChangeHandler(handler) {
+    const runtime = this.appConfig.runtime ?? {};
+    this.appConfig.runtime = runtime;
+    runtime.registeredScriptEntrypointChangeHandlers ??= [];
+    runtime.registeredScriptEntrypointChangeHandlers.push(handler);
+  }
+  /**
+   * Notifies integration handlers that a registered script entrypoint changed.
+   */
+  async notifyRegisteredScriptEntrypointChange(filePath) {
+    const handlers = this.appConfig.runtime?.registeredScriptEntrypointChangeHandlers ?? [];
+    for (const handler of handlers) {
+      try {
+        await handler(filePath);
+      } catch (error) {
+        appLogger.error(
+          `Failed to handle registered script entrypoint change for ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
   /**
    * Resets runtime-owned graph state and invalidates server modules.
    */
@@ -55,8 +80,18 @@ class DevelopmentInvalidationService {
         category: "include-source",
         invalidateServerModules: true,
         refreshRoutes: false,
-        reloadBrowser: true,
-        delegateToHmr: false,
+        reloadBrowser: false,
+        delegateToHmr: true,
+        processorHandledAsset: false
+      };
+    }
+    if (this.isExplicitServerViewFile(filePath)) {
+      return {
+        category: "explicit-server-view",
+        invalidateServerModules: true,
+        refreshRoutes: false,
+        reloadBrowser: false,
+        delegateToHmr: true,
         processorHandledAsset: false
       };
     }
@@ -148,6 +183,25 @@ class DevelopmentInvalidationService {
     }
     return /\.(?:[cm]?ts|[jt]sx?|mdx)$/u.test(resolvedPath);
   }
+  /**
+   * Returns whether the file is an explicit server-rendered view module.
+   *
+   * @remarks
+   * These modules are typically registered through `renderServerModule` in
+   * `app.ts` rather than the filesystem router. They need a full browser reload
+   * because their HTML is produced on the server, not through client HMR entrypoints.
+   */
+  isExplicitServerViewFile(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    const viewsDir = path.join(this.appConfig.absolutePaths.srcDir, "views");
+    if (resolvedPath !== viewsDir && !resolvedPath.startsWith(`${viewsDir}${path.sep}`)) {
+      return false;
+    }
+    if (this.appConfig.templatesExt.some((extension) => resolvedPath.endsWith(extension))) {
+      return true;
+    }
+    return /\.(?:[cm]?ts|[jt]sx?|mdx)$/u.test(resolvedPath);
+  }
   /**
    * Returns whether the file is a server-executed source module outside the
    * special route/include buckets.

package/src/services/module-loading/README.md

@@ -0,0 +1,49 @@
+# Module Loading
+
+Server-side source loading for framework-owned page modules, includes, and related templates.
+
+## Import stack
+
+```
+Call site (route scan, renderer, SSG, API)
+  └─ AppModuleLoader.importModule()          app-server-module-transpiler.service.ts
+       ├─ merges server build plugins + JSX ownership plugins
+       ├─ resolves route-module BuildExecutor
+       └─ PageModuleImportService.importModule()
+            ├─ dev + host loader → host runtime (Node only, when configured)
+            ├─ production disk cache → route-module build cache
+            ├─ unified pages graph → prebuilt chunk import
+            └─ Rolldown per-page build → dynamic import of transpiled output
+```
+
+`ServerModuleTranspiler` is a thin wrapper that injects `rootDir`, optional default plugins, and invalidation version into the same `PageModuleImportService` path. App code should prefer `getAppModuleLoader(appConfig)` or `getAppServerModuleTranspiler(appConfig)`.
+
+## Host vs app ownership
+
+| Path                    | When                                                                                         |
+| ----------------------- | -------------------------------------------------------------------------------------------- |
+| Host loader             | `appConfig.runtime.hostModuleLoader` set (Vite host) and file supports direct source loading |
+| Ecopages build pipeline | Framework-owned template files under `pages/`, `includes/`, etc.                             |
+
+`shouldAppUseHostModuleLoader()` encodes the directory + extension rules. Bun always uses the build pipeline today.
+
+## Caching layers
+
+1. **In-memory promise cache** (`PageModuleImportService.importCache`) — keyed by file path, resolved `outdir`, JSX/plugin inputs, file hash, and invalidation version. Cleared by `invalidateDevelopmentGraph()`.
+2. **Disk transpile cache** (`.eco/.server-modules/.build-cache.json`) — production only; see route-module build cache slice.
+3. **Unified graph manifest** — production static export fast path; see build layer docs.
+
+## Files
+
+| File                                      | Role                                                      |
+| ----------------------------------------- | --------------------------------------------------------- |
+| `page-module-import.service.ts`           | Core import/cache/build orchestration                     |
+| `app-module-loader.service.ts`            | App-facing loader interface                               |
+| `app-server-module-transpiler.service.ts` | Factory for app-scoped loader + transpiler                |
+| `server-module-transpiler.service.ts`     | Injectable transpiler boundary for tests and bootstrap    |
+| `host-module-loader-registry.ts`          | Process-global host loader fallback for embedded runtimes |
+| `source-module-support.ts`                | Extension allowlist for host direct loading               |
+
+## Development invalidation
+
+`DevelopmentInvalidationService.invalidateServerModules()` bumps the app-owned invalidation version and calls `appModuleLoader.invalidateDevelopmentGraph()`, which clears the in-memory import cache and increments the per-service invalidation counter used in cache keys and dev `?update=` query params.

package/src/services/module-loading/app-server-module-transpiler.service.js

@@ -1,5 +1,6 @@
-import { getAppBuildExecutor, getAppServerBuildPlugins } from "../../build/build-adapter.js";
-import { createForeignJsxOverridePlugin } from "../../plugins/foreign-jsx-override-plugin.js";
+import { getAppServerBuildPlugins } from "../../build/build-adapter.js";
+import { requireBuildRuntime } from "../../build/build-runtime.js";
+import { getJsxOwnershipPlugins } from "../../build/jsx-ownership-plugins.js";
 import path from "node:path";
 import { DevelopmentInvalidationService } from "../invalidation/development-invalidation.service.js";
 import {} from "./app-module-loader.service.js";
@@ -37,22 +38,9 @@ function setAppHostModuleLoader(appConfig, hostModuleLoader) {
     hostModuleLoader
   };
 }
-function getJsxOwnershipPlugins(appConfig) {
-  const jsxExtensions = (appConfig.integrations ?? []).filter((integration) => integration.jsxImportSource).flatMap(
-    (integration) => integration.extensions.filter((extension) => extension.endsWith(".tsx") || extension.endsWith(".jsx")).map((extension) => ({ integration, extension }))
-  ).sort((left, right) => right.extension.length - left.extension.length);
-  return jsxExtensions.map(
-    ({ integration, extension }) => createForeignJsxOverridePlugin({
-      hostJsxImportSource: integration.jsxImportSource,
-      foreignExtensions: [extension],
-      excludeExtensions: jsxExtensions.filter((candidate) => candidate.extension.length > extension.length).filter((candidate) => candidate.extension.endsWith(extension)).map((candidate) => candidate.extension),
-      name: `ecopages-jsx-ownership-${integration.name}-${extension.replace(/[^a-zA-Z0-9]+/g, "-")}`
-    })
-  );
-}
 function createAppModuleLoader(appConfig) {
   const invalidationService = new DevelopmentInvalidationService(appConfig);
-  const pageModuleImportService = new PageModuleImportService({
+  const pageModuleImportService = new PageModuleImportService(appConfig, {
     canLoadSourceModuleFromHost: (filePath) => shouldAppUseHostModuleLoader(appConfig, filePath),
     getHostModuleLoader: () => getAppHostModuleLoader(appConfig)
   });
@@ -69,7 +57,7 @@ function createAppModuleLoader(appConfig) {
       return await pageModuleImportService.importModule({
         ...options,
         ...mergedPlugins.length > 0 ? { plugins: mergedPlugins } : {},
-        buildExecutor: options.buildExecutor ?? getAppBuildExecutor(appConfig),
+        buildExecutor: options.buildExecutor ?? requireBuildRuntime(appConfig).getProfile("route-module"),
         invalidationVersion
       });
     },

package/src/services/module-loading/page-module-import.service.d.ts

@@ -1,5 +1,6 @@
 import { build, type BuildExecutor, type BuildResult } from '../../build/build-adapter.js';
 import type { EcoBuildPlugin } from '../../build/build-types.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
 import type { SourceModuleLoaderFactory } from './module-loading-types.js';
 interface PageModuleImportBaseOptions {
     filePath: string;
@@ -59,10 +60,12 @@ export interface PageModuleImportDependencies {
  * transpilation settings, and error semantics across the different callers.
  */
 export declare class PageModuleImportService {
+    private readonly appConfig?;
     private readonly dependencies;
+    private readonly dependencyHasher;
     private readonly importCache;
     private developmentInvalidationVersion;
-    constructor(dependencies?: Partial<PageModuleImportDependencies>);
+    constructor(appConfig?: EcoPagesAppConfig, dependencies?: Partial<PageModuleImportDependencies>);
     /**
      * Clears the shared import cache used by framework-owned page-module loads.
      */
@@ -91,5 +94,6 @@ export declare class PageModuleImportService {
      */
     importModule<T = unknown>(options: PageModuleBuildImportOptions): Promise<T>;
     private loadModule;
+    private getRouteModuleBuildCache;
 }
 export {};

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

@@ -2,19 +2,43 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { fileSystem } from "@ecopages/file-system";
 import { build } from "../../build/build-adapter.js";
+import { resolveBuildProfileOptions } from "../../build/build-profile-options.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 {
+  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(dependencies) {
+  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.
@@ -33,6 +57,7 @@ class PageModuleImportService {
    */
   invalidateDevelopmentGraph() {
     this.clearImportCache();
+    this.dependencyHasher.clearMemo();
     this.developmentInvalidationVersion += 1;
   }
   /**
@@ -70,6 +95,7 @@ class PageModuleImportService {
       runtime,
       filePath,
       options.rootDir,
+      path.resolve(options.outdir),
       splitting ?? "default",
       externalPackages ?? "default",
       options.cacheScope ?? "default",
@@ -80,13 +106,21 @@ class PageModuleImportService {
     ].join("::");
     const cachedModule = this.importCache.get(cacheKey);
     if (cachedModule) {
-      return await cachedModule;
+      if (!cachedModule.dependencyHashes) {
+        return await cachedModule.promise;
+      }
+      this.dependencyHasher.clearMemo();
+      if (this.dependencyHasher.matchesStoredHashes(cachedModule.dependencyHashes, filePath, fileHash)) {
+        return await cachedModule.promise;
+      }
+      this.importCache.delete(cacheKey);
     }
     const importPromise = this.loadModule({
       ...options,
-      fileHash
+      fileHash,
+      importCacheKey: cacheKey
     });
-    this.importCache.set(cacheKey, importPromise);
+    this.importCache.set(cacheKey, { promise: importPromise });
     try {
       return await importPromise;
     } catch (error) {
@@ -95,7 +129,13 @@ class PageModuleImportService {
     }
   }
   async loadModule(options) {
-    const { filePath, invalidationVersion = this.developmentInvalidationVersion, cacheScope, fileHash } = options;
+    const {
+      filePath,
+      invalidationVersion = this.developmentInvalidationVersion,
+      cacheScope,
+      fileHash,
+      importCacheKey
+    } = options;
     const {
       rootDir,
       outdir,
@@ -104,39 +144,70 @@ class PageModuleImportService {
       transpileErrorMessage = (details) => `Error transpiling page module: ${details}`,
       noOutputMessage = (targetFilePath) => `No transpiled output generated for page module: ${targetFilePath}`
     } = options;
-    const fileBaseName = path.basename(filePath, path.extname(filePath));
-    const cacheScopeSuffix = cacheScope ? `-${sanitizeCacheScope(cacheScope)}` : "";
-    const invalidationSuffix = shouldVersionBuildOutputPath(invalidationVersion) ? `-v${invalidationVersion}` : "";
-    const outputFileName = `${fileBaseName}-${fileHash}${cacheScopeSuffix}${invalidationSuffix}.mjs`;
-    const outputNamingTemplate = `${fileBaseName}-${fileHash}${cacheScopeSuffix}${invalidationSuffix}.[ext]`;
-    const buildResult = await this.dependencies.buildModule(
-      {
+    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
+      );
+    }
+    if (!cacheScope && shouldBuildPagesUnifiedGraph() && this.appConfig && isPagesUnifiedGraphPage(filePath, this.appConfig)) {
+      const graphModule = await importPagesUnifiedGraphModule(this.appConfig, filePath);
+      if (graphModule !== void 0) {
+        return graphModule;
+      }
+    }
+    recordPageModuleBuildInvocation();
+    const buildOptions = {
+      ...resolveBuildProfileOptions("route-module", this.appConfig ?? { rootDir }, {
         entrypoints: [filePath],
-        root: rootDir,
         outdir,
-        target: "es2022",
-        format: "esm",
-        sourcemap: "none",
-        splitting: splitting ?? true,
-        minify: false,
         naming: outputNamingTemplate,
-        externalPackages: true,
+        splitting: splitting ?? true,
         jsx: options.jsx,
         plugins: options.plugins,
         ...externalPackages !== void 0 ? { externalPackages } : {}
-      },
-      options.buildExecutor
-    );
+      }),
+      root: rootDir,
+      entrypoints: [filePath]
+    };
+    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 preferredOutputPath = path.join(outdir, outputFileName);
     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);
+    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({
+      ...options,
+      fileHash,
+      outputPath: compiledOutput,
+      dependencyModulePaths
+    });
     const compiledOutputUrl = pathToFileURL(compiledOutput);
     if (shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope)) {
       compiledOutputUrl.searchParams.set(
@@ -149,6 +220,9 @@ class PageModuleImportService {
       compiledOutputUrl.href
     );
   }
+  getRouteModuleBuildCache(outdir) {
+    return getSharedRouteModuleBuildCache(outdir, this.appConfig);
+  }
 }
 function createRuntimeModuleUrl(filePath, fileHash, invalidationVersion, cacheScope) {
   const moduleUrl = pathToFileURL(filePath);
@@ -163,31 +237,9 @@ function createRuntimeModuleUrl(filePath, fileHash, invalidationVersion, cacheSc
 function shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope) {
   return process.env.NODE_ENV === "development" || invalidationVersion > 0 || !!cacheScope;
 }
-function shouldVersionBuildOutputPath(invalidationVersion) {
-  return typeof Bun !== "undefined" && invalidationVersion > 0;
-}
 function sanitizeCacheScope(cacheScope) {
   return cacheScope.replace(/[^a-zA-Z0-9_-]+/g, "-");
 }
-function createJsxCacheKey(jsx) {
-  if (!jsx) {
-    return "jsx:default";
-  }
-  return JSON.stringify({
-    development: jsx.development ?? false,
-    factory: jsx.factory ?? null,
-    fragment: jsx.fragment ?? null,
-    importSource: jsx.importSource ?? null,
-    runtime: jsx.runtime ?? null,
-    sideEffects: jsx.sideEffects ?? null
-  });
-}
-function createPluginCacheKey(plugins) {
-  if (!plugins || plugins.length === 0) {
-    return "plugins:default";
-  }
-  return `plugins:${plugins.map((plugin) => plugin.name).join(",")}`;
-}
 export {
   PageModuleImportService
 };