@ecopages/core 0.2.0-beta.4 → 0.2.0-beta.41

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

@@ -1,193 +1,231 @@
-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 { supportsSourceModuleLoading } from "./source-module-support.js";
-class PageModuleImportService {
-  dependencies;
-  importCache = /* @__PURE__ */ new Map();
-  developmentInvalidationVersion = 0;
-  constructor(dependencies) {
-    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,
-      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 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(
-      {
-        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));
+    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 = resolvePageModuleOutputFileName({
+            filePath,
+            fileHash,
+        });
+        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));
     }
-    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));
+    getRouteModuleBuildCache(outdir) {
+        return getSharedRouteModuleBuildCache(outdir, this.appConfig);
     }
-    normalizeNodeRuntimeBuildOutputFile(compiledOutput, 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
-    );
-  }
-}
-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 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 createRuntimeModuleUrl(filePath, fileHash, developmentImportGeneration) {
+    const moduleUrl = pathToFileURL(filePath);
+    if (shouldAddRuntimeUpdateQuery()) {
+        moduleUrl.searchParams.set('update', `${fileHash}-${developmentImportGeneration}`);
+    }
+    return moduleUrl;
 }
-function createPluginCacheKey(plugins) {
-  if (!plugins || plugins.length === 0) {
-    return "plugins:default";
-  }
-  return `plugins:${plugins.map((plugin) => plugin.name).join(",")}`;
+function shouldAddRuntimeUpdateQuery() {
+    return process.env.NODE_ENV === 'development';
 }
-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,51 @@
+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');
+}
+/**
+ * @deprecated Use {@link getServerModuleBuildCacheOutdir}.
+ */
+export const getRouteModuleBuildCacheOutdir = getServerModuleBuildCacheOutdir;
+function getRouteModuleBuildCacheMap(appConfig) {
+    const existing = appConfig.runtime?.routeModuleBuildCaches;
+    if (existing) {
+        return existing;
+    }
+    const routeModuleBuildCaches = new Map();
+    appConfig.runtime = {
+        ...(appConfig.runtime ?? {}),
+        routeModuleBuildCaches,
+    };
+    return routeModuleBuildCaches;
+}
+/**
+ * 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;
+}

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,3 @@
+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

@@ -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;
+}