@ecopages/core 0.2.0-beta.6 → 0.2.0-beta.8

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,5 @@
 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';
+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.
  *
@@ -62,6 +62,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

@@ -60,6 +60,16 @@ class DevelopmentInvalidationService {
         processorHandledAsset: false
       };
     }
+    if (this.isExplicitServerViewFile(filePath)) {
+      return {
+        category: "explicit-server-view",
+        invalidateServerModules: true,
+        refreshRoutes: false,
+        reloadBrowser: true,
+        delegateToHmr: false,
+        processorHandledAsset: false
+      };
+    }
     if (this.isRouteSourceFile(filePath)) {
       return {
         category: "route-source",
@@ -148,6 +158,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,5 @@
-import { getAppBuildExecutor, getAppServerBuildPlugins } from "../../build/build-adapter.js";
-import { createForeignJsxOverridePlugin } from "../../plugins/foreign-jsx-override-plugin.js";
+import { getAppRouteModuleBuildExecutor, getAppServerBuildPlugins } from "../../build/build-adapter.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 +37,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 +56,7 @@ function createAppModuleLoader(appConfig) {
       return await pageModuleImportService.importModule({
         ...options,
         ...mergedPlugins.length > 0 ? { plugins: mergedPlugins } : {},
-        buildExecutor: options.buildExecutor ?? getAppBuildExecutor(appConfig),
+        buildExecutor: options.buildExecutor ?? getAppRouteModuleBuildExecutor(appConfig),
         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,11 @@ export interface PageModuleImportDependencies {
  * transpilation settings, and error semantics across the different callers.
  */
 export declare class PageModuleImportService {
+    private readonly appConfig?;
     private readonly dependencies;
     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 +93,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

@@ -3,12 +3,27 @@ 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(dependencies) {
+  constructor(appConfig, dependencies) {
+    this.appConfig = appConfig;
     this.dependencies = {
       hashFile: dependencies?.hashFile ?? ((filePath) => fileSystem.hash(filePath)),
       buildModule: dependencies?.buildModule ?? ((options, buildExecutor) => build(options, buildExecutor)),
@@ -70,6 +85,7 @@ class PageModuleImportService {
       runtime,
       filePath,
       options.rootDir,
+      path.resolve(options.outdir),
       splitting ?? "default",
       externalPackages ?? "default",
       options.cacheScope ?? "default",
@@ -104,11 +120,32 @@ 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 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 buildResult = await this.dependencies.buildModule(
       {
         entrypoints: [filePath],
@@ -131,12 +168,17 @@ class PageModuleImportService {
       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);
+    routeModuleBuildCache.recordBuild({
+      ...options,
+      fileHash,
+      outputPath: compiledOutput,
+      dependencyModulePaths: resolveRouteModuleDependencyPaths(buildResult, filePath, rootDir)
+    });
     const compiledOutputUrl = pathToFileURL(compiledOutput);
     if (shouldAddRuntimeUpdateQuery(invalidationVersion, cacheScope)) {
       compiledOutputUrl.searchParams.set(
@@ -149,6 +191,9 @@ class PageModuleImportService {
       compiledOutputUrl.href
     );
   }
+  getRouteModuleBuildCache(outdir) {
+    return getSharedRouteModuleBuildCache(outdir, this.appConfig);
+  }
 }
 function createRuntimeModuleUrl(filePath, fileHash, invalidationVersion, cacheScope) {
   const moduleUrl = pathToFileURL(filePath);
@@ -163,31 +208,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
 };

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

@@ -0,0 +1,24 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.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 declare function getServerModuleBuildCacheOutdir(appConfig: EcoPagesAppConfig): string;
+/**
+ * @deprecated Use {@link getServerModuleBuildCacheOutdir}.
+ */
+export declare const getRouteModuleBuildCacheOutdir: typeof getServerModuleBuildCacheOutdir;
+/**
+ * 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 declare function getSharedRouteModuleBuildCache(outdir: string, appConfig?: EcoPagesAppConfig): RouteModuleBuildCache;

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

@@ -0,0 +1,37 @@
+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");
+}
+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;
+}
+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.d.ts

@@ -0,0 +1,4 @@
+export type { RouteModuleDependencyHashes } from './route-module-dependency-hasher.js';
+export { ROUTE_MODULE_BUILD_CACHE_FILENAME, createEmptyRouteModuleBuildCacheManifest, createPersistedRouteModuleBuildKey, createPluginCacheKey, createJsxCacheKey, hashPluginSetup, getCorePackageVersion, normalizeRouteModuleCachePath, readRouteModuleBuildCacheManifest, resolvePageModuleOutputFileName, shouldPersistRouteModuleBuildCache, writeRouteModuleBuildCacheManifest, type RouteModuleBuildCacheEntry, type RouteModuleBuildCacheLookup, type RouteModuleBuildCacheManifest, type RouteModuleStaticRenderCacheContext, type RouteModuleStaticRenderCacheEntry, } 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.js

@@ -0,0 +1,38 @@
+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
+};

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

@@ -0,0 +1,57 @@
+import type { PageModuleBuildImportOptions } from './page-module-import.service.js';
+import { RouteModuleDependencyHasher, type RouteModuleDependencyHashes } from './route-module-dependency-hasher.js';
+import { type RouteModuleBuildCacheLookup, type RouteModuleBuildCacheManifest, type RouteModuleStaticRenderCacheContext } from './route-module-build-manifest.js';
+export type { RouteModuleDependencyHashes };
+type RouteModuleBuildCacheDependencies = {
+    readManifest: (manifestPath: string) => RouteModuleBuildCacheManifest | undefined;
+    writeManifest: (manifestPath: string, manifest: RouteModuleBuildCacheManifest) => void;
+    exists: (filePath: string) => boolean;
+    getCorePackageVersion: () => string;
+    createDependencyHasher: () => RouteModuleDependencyHasher;
+};
+/**
+ * Persists route-module transpile and static-render metadata under one server outdir.
+ */
+export declare class RouteModuleBuildCache {
+    private readonly manifestPath;
+    private readonly dependencies;
+    private readonly dependencyHasher;
+    private manifest;
+    private manifestLoaded;
+    constructor(outdir: string, dependencies?: Partial<RouteModuleBuildCacheDependencies>);
+    lookup(options: PageModuleBuildImportOptions & {
+        fileHash: string;
+    }): RouteModuleBuildCacheLookup | undefined;
+    recordBuild(options: PageModuleBuildImportOptions & {
+        fileHash: string;
+        outputPath: string;
+        dependencyModulePaths?: readonly string[];
+    }): void;
+    isIncrementalStaticGenerationAvailable(context: RouteModuleStaticRenderCacheContext): boolean;
+    ensureIncrementalStaticGenerationContext(context: RouteModuleStaticRenderCacheContext): void;
+    canReuseStaticRender(options: {
+        sourceFile: string;
+        pathname: string;
+        renderedOutputPath: string;
+        context: RouteModuleStaticRenderCacheContext;
+        force?: boolean;
+    }): boolean;
+    lookupStaticRender(options: {
+        filePath: string;
+        pathname: string;
+        sourceHash: string;
+        renderedOutputPath: string;
+        context: RouteModuleStaticRenderCacheContext;
+    }): boolean;
+    recordStaticRender(options: {
+        filePath: string;
+        pathname: string;
+        sourceHash: string;
+        renderedOutputPath: string;
+        context: RouteModuleStaticRenderCacheContext;
+    }): void;
+    resetMemory(): void;
+    pruneStaleRenderedOutputs(activePathnames: ReadonlySet<string>): string[];
+    private loadManifest;
+    private persistManifest;
+}