@ecopages/core 0.2.0-beta.9 → 0.2.0-rc.1

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

@@ -1,203 +1,220 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { RouteModuleDependencyHasher } from "./route-module-dependency-hasher.js";
-import {
-  ROUTE_MODULE_BUILD_CACHE_FILENAME,
-  createEmptyRouteModuleBuildCacheManifest,
-  createPersistedRouteModuleBuildKey,
-  getCorePackageVersion,
-  normalizeRouteModuleCachePath,
-  readRouteModuleBuildCacheManifest,
-  shouldPersistRouteModuleBuildCache,
-  writeRouteModuleBuildCacheManifest
-} from "./route-module-build-manifest.js";
-class RouteModuleBuildCache {
-  manifestPath;
-  dependencies;
-  dependencyHasher;
-  manifest;
-  manifestLoaded = false;
-  constructor(outdir, dependencies) {
-    this.manifestPath = path.join(outdir, ROUTE_MODULE_BUILD_CACHE_FILENAME);
-    this.dependencies = {
-      readManifest: dependencies?.readManifest ?? readRouteModuleBuildCacheManifest,
-      writeManifest: dependencies?.writeManifest ?? writeRouteModuleBuildCacheManifest,
-      exists: dependencies?.exists ?? ((filePath) => fileSystem.exists(filePath)),
-      getCorePackageVersion: dependencies?.getCorePackageVersion ?? getCorePackageVersion,
-      createDependencyHasher: dependencies?.createDependencyHasher ?? (() => new RouteModuleDependencyHasher())
-    };
-    this.dependencyHasher = this.dependencies.createDependencyHasher();
-  }
-  lookup(options) {
-    if (!shouldPersistRouteModuleBuildCache(options)) {
-      return void 0;
-    }
-    const manifest = this.loadManifest();
-    if (manifest.invalidationVersion !== this.dependencies.getCorePackageVersion()) {
-      return void 0;
-    }
-    const buildKey = createPersistedRouteModuleBuildKey(options);
-    const cacheFilePath = normalizeRouteModuleCachePath(options.filePath);
-    const entry = manifest.entries[cacheFilePath];
-    if (!entry || entry.sourceHash !== options.fileHash || entry.buildKey !== buildKey) {
-      return void 0;
-    }
-    if (!this.dependencyHasher.matchesStoredHashes(entry.dependencyHashes, cacheFilePath, options.fileHash)) {
-      return void 0;
-    }
-    const outputPath = path.isAbsolute(entry.outputPath) ? entry.outputPath : path.join(options.outdir, entry.outputPath);
-    if (!this.dependencies.exists(outputPath)) {
-      return void 0;
-    }
-    return { outputPath, entry };
-  }
-  recordBuild(options) {
-    if (!shouldPersistRouteModuleBuildCache(options)) {
-      return;
-    }
-    const cacheFilePath = normalizeRouteModuleCachePath(options.filePath);
-    const dependencyModulePaths = options.dependencyModulePaths && options.dependencyModulePaths.length > 0 ? options.dependencyModulePaths : [cacheFilePath];
-    const dependencyHashes = this.dependencyHasher.createDependencyHashes(dependencyModulePaths);
-    dependencyHashes[cacheFilePath] = options.fileHash;
-    const manifest = this.loadManifest();
-    const existingEntry = manifest.entries[cacheFilePath];
-    manifest.invalidationVersion = this.dependencies.getCorePackageVersion();
-    manifest.entries[cacheFilePath] = {
-      sourceHash: options.fileHash,
-      outputPath: options.outputPath,
-      builtAt: Date.now(),
-      buildKey: createPersistedRouteModuleBuildKey(options),
-      dependencyHashes,
-      renderedOutputs: existingEntry?.renderedOutputs
-    };
-    this.persistManifest(manifest);
-  }
-  isIncrementalStaticGenerationAvailable(context) {
-    if (process.env.NODE_ENV !== "production") {
-      return false;
-    }
-    const manifest = this.loadManifest();
-    if (manifest.invalidationVersion !== this.dependencies.getCorePackageVersion()) {
-      return false;
-    }
-    return manifest.configHash === context.configHash && manifest.buildInputsFingerprint === context.buildInputsFingerprint;
-  }
-  ensureIncrementalStaticGenerationContext(context) {
-    if (process.env.NODE_ENV !== "production") {
-      return;
-    }
-    const manifest = this.loadManifest();
-    manifest.invalidationVersion = this.dependencies.getCorePackageVersion();
-    manifest.configHash = context.configHash;
-    manifest.buildInputsFingerprint = context.buildInputsFingerprint;
-    this.persistManifest(manifest);
-  }
-  canReuseStaticRender(options) {
-    if (options.force) {
-      return false;
-    }
-    if (!fileSystem.exists(options.sourceFile)) {
-      return false;
-    }
-    const sourceHash = fileSystem.hash(options.sourceFile);
-    return this.lookupStaticRender({
-      filePath: options.sourceFile,
-      pathname: options.pathname,
-      sourceHash,
-      renderedOutputPath: options.renderedOutputPath,
-      context: options.context
-    });
-  }
-  lookupStaticRender(options) {
-    if (!this.isIncrementalStaticGenerationAvailable(options.context)) {
-      return false;
-    }
-    const manifest = this.loadManifest();
-    const cacheFilePath = normalizeRouteModuleCachePath(options.filePath);
-    const entry = manifest.entries[cacheFilePath];
-    const renderedOutput = entry?.renderedOutputs?.[options.pathname];
-    if (!entry || !renderedOutput) {
-      return false;
-    }
-    if (entry.sourceHash !== options.sourceHash || renderedOutput.sourceHash !== options.sourceHash) {
-      return false;
-    }
-    if (!this.dependencyHasher.matchesStoredHashes(entry.dependencyHashes, cacheFilePath, options.sourceHash)) {
-      return false;
-    }
-    const cachedOutputPath = path.isAbsolute(renderedOutput.renderedOutputPath) ? renderedOutput.renderedOutputPath : path.resolve(renderedOutput.renderedOutputPath);
-    if (cachedOutputPath !== path.resolve(options.renderedOutputPath)) {
-      return false;
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import { RouteModuleDependencyHasher } from './route-module-dependency-hasher.js';
+import { ROUTE_MODULE_BUILD_CACHE_FILENAME, createEmptyRouteModuleBuildCacheManifest, createPersistedRouteModuleBuildKey, getCorePackageVersion, normalizeRouteModuleCachePath, readRouteModuleBuildCacheManifest, shouldPersistRouteModuleBuildCache, writeRouteModuleBuildCacheManifest, } from './route-module-build-manifest.js';
+import { isProductionCacheManifestCurrent, matchesProductionCacheFingerprint, } from '../../build/cache/production-build-cache.js';
+/**
+ * Persists route-module transpile and static-render metadata under one server outdir.
+ */
+export class RouteModuleBuildCache {
+    manifestPath;
+    dependencies;
+    dependencyHasher;
+    manifest;
+    manifestLoaded = false;
+    constructor(outdir, dependencies) {
+        this.manifestPath = path.join(outdir, ROUTE_MODULE_BUILD_CACHE_FILENAME);
+        this.dependencies = {
+            readManifest: dependencies?.readManifest ?? readRouteModuleBuildCacheManifest,
+            writeManifest: dependencies?.writeManifest ?? writeRouteModuleBuildCacheManifest,
+            exists: dependencies?.exists ?? ((filePath) => fileSystem.exists(filePath)),
+            getCorePackageVersion: dependencies?.getCorePackageVersion ?? getCorePackageVersion,
+            createDependencyHasher: dependencies?.createDependencyHasher ?? (() => new RouteModuleDependencyHasher()),
+        };
+        this.dependencyHasher = this.dependencies.createDependencyHasher();
+    }
+    lookup(options) {
+        if (!shouldPersistRouteModuleBuildCache(options)) {
+            return undefined;
+        }
+        const manifest = this.loadManifest();
+        if (manifest.corePackageVersion !== this.dependencies.getCorePackageVersion()) {
+            return undefined;
+        }
+        const buildKey = createPersistedRouteModuleBuildKey(options, options.sourceTransforms);
+        const cacheFilePath = normalizeRouteModuleCachePath(options.filePath);
+        const entry = manifest.entries[cacheFilePath];
+        if (!entry || entry.sourceHash !== options.fileHash || entry.buildKey !== buildKey) {
+            return undefined;
+        }
+        if (!this.dependencyHasher.matchesStoredHashes(entry.dependencyHashes, cacheFilePath, options.fileHash)) {
+            return undefined;
+        }
+        const outputPath = path.isAbsolute(entry.outputPath)
+            ? entry.outputPath
+            : path.join(options.outdir, entry.outputPath);
+        if (!this.dependencies.exists(outputPath)) {
+            return undefined;
+        }
+        return { outputPath, entry };
     }
-    return this.dependencies.exists(cachedOutputPath);
-  }
-  recordStaticRender(options) {
-    if (process.env.NODE_ENV !== "production") {
-      return;
+    recordBuild(options) {
+        if (!shouldPersistRouteModuleBuildCache(options)) {
+            return;
+        }
+        const cacheFilePath = normalizeRouteModuleCachePath(options.filePath);
+        const dependencyModulePaths = options.dependencyModulePaths && options.dependencyModulePaths.length > 0
+            ? options.dependencyModulePaths
+            : [cacheFilePath];
+        const dependencyHashes = this.dependencyHasher.createDependencyHashes(dependencyModulePaths);
+        dependencyHashes[cacheFilePath] = options.fileHash;
+        const manifest = this.loadManifest();
+        const existingEntry = manifest.entries[cacheFilePath];
+        manifest.corePackageVersion = this.dependencies.getCorePackageVersion();
+        manifest.entries[cacheFilePath] = {
+            sourceHash: options.fileHash,
+            outputPath: options.outputPath,
+            builtAt: Date.now(),
+            buildKey: createPersistedRouteModuleBuildKey(options, options.sourceTransforms),
+            dependencyHashes,
+            renderedOutputs: existingEntry?.renderedOutputs,
+        };
+        this.persistManifest(manifest);
+    }
+    isIncrementalStaticGenerationAvailable(context) {
+        if (process.env.NODE_ENV !== 'production') {
+            return false;
+        }
+        const manifest = this.loadManifest();
+        if (!isProductionCacheManifestCurrent(manifest, this.dependencies.getCorePackageVersion())) {
+            return false;
+        }
+        return (manifest.configHash === context.configHash &&
+            matchesProductionCacheFingerprint(manifest, context.buildInputsFingerprint));
     }
-    const cacheFilePath = normalizeRouteModuleCachePath(options.filePath);
-    const manifest = this.loadManifest();
-    const existingEntry = manifest.entries[cacheFilePath];
-    manifest.invalidationVersion = this.dependencies.getCorePackageVersion();
-    manifest.configHash = options.context.configHash;
-    manifest.buildInputsFingerprint = options.context.buildInputsFingerprint;
-    manifest.entries[cacheFilePath] = {
-      sourceHash: options.sourceHash,
-      outputPath: existingEntry?.outputPath ?? "",
-      builtAt: existingEntry?.builtAt ?? Date.now(),
-      buildKey: existingEntry?.buildKey ?? "",
-      dependencyHashes: existingEntry?.dependencyHashes,
-      renderedOutputs: {
-        ...existingEntry?.renderedOutputs ?? {},
-        [options.pathname]: {
-          renderedOutputPath: options.renderedOutputPath,
-          renderedAt: Date.now(),
-          sourceHash: options.sourceHash
-        }
-      }
-    };
-    this.persistManifest(manifest);
-  }
-  resetMemory() {
-    this.manifest = void 0;
-    this.manifestLoaded = false;
-  }
-  pruneStaleRenderedOutputs(activePathnames) {
-    if (process.env.NODE_ENV !== "production") {
-      return [];
+    ensureIncrementalStaticGenerationContext(context) {
+        if (process.env.NODE_ENV !== 'production') {
+            return;
+        }
+        const manifest = this.loadManifest();
+        manifest.corePackageVersion = this.dependencies.getCorePackageVersion();
+        manifest.configHash = context.configHash;
+        manifest.buildInputsFingerprint = context.buildInputsFingerprint;
+        this.persistManifest(manifest);
+    }
+    canReuseStaticRender(options) {
+        if (options.force) {
+            return false;
+        }
+        if (!fileSystem.exists(options.sourceFile)) {
+            return false;
+        }
+        const sourceHash = fileSystem.hash(options.sourceFile);
+        return this.lookupStaticRender({
+            filePath: options.sourceFile,
+            pathname: options.pathname,
+            sourceHash,
+            renderedOutputPath: options.renderedOutputPath,
+            context: options.context,
+        });
+    }
+    lookupStaticRender(options) {
+        if (!this.isIncrementalStaticGenerationAvailable(options.context)) {
+            return false;
+        }
+        const manifest = this.loadManifest();
+        const cacheFilePath = normalizeRouteModuleCachePath(options.filePath);
+        const entry = manifest.entries[cacheFilePath];
+        const renderedOutput = entry?.renderedOutputs?.[options.pathname];
+        if (!entry || !renderedOutput) {
+            return false;
+        }
+        if (entry.sourceHash !== options.sourceHash || renderedOutput.sourceHash !== options.sourceHash) {
+            return false;
+        }
+        if (!this.dependencyHasher.matchesStoredHashes(entry.dependencyHashes, cacheFilePath, options.sourceHash)) {
+            return false;
+        }
+        const cachedOutputPath = path.isAbsolute(renderedOutput.renderedOutputPath)
+            ? renderedOutput.renderedOutputPath
+            : path.resolve(renderedOutput.renderedOutputPath);
+        if (cachedOutputPath !== path.resolve(options.renderedOutputPath)) {
+            return false;
+        }
+        return this.dependencies.exists(cachedOutputPath);
     }
-    const manifest = this.loadManifest();
-    const removedOutputPaths = [];
-    for (const entry of Object.values(manifest.entries)) {
-      if (!entry.renderedOutputs) {
-        continue;
-      }
-      for (const [pathname, renderedOutput] of Object.entries(entry.renderedOutputs)) {
-        if (activePathnames.has(pathname)) {
-          continue;
-        }
-        removedOutputPaths.push(renderedOutput.renderedOutputPath);
-        delete entry.renderedOutputs[pathname];
-      }
+    recordStaticRender(options) {
+        if (process.env.NODE_ENV !== 'production') {
+            return;
+        }
+        const cacheFilePath = normalizeRouteModuleCachePath(options.filePath);
+        const manifest = this.loadManifest();
+        const existingEntry = manifest.entries[cacheFilePath];
+        manifest.corePackageVersion = this.dependencies.getCorePackageVersion();
+        manifest.configHash = options.context.configHash;
+        manifest.buildInputsFingerprint = options.context.buildInputsFingerprint;
+        manifest.entries[cacheFilePath] = {
+            sourceHash: options.sourceHash,
+            outputPath: existingEntry?.outputPath ?? '',
+            builtAt: existingEntry?.builtAt ?? Date.now(),
+            buildKey: existingEntry?.buildKey ?? '',
+            dependencyHashes: existingEntry?.dependencyHashes,
+            renderedOutputs: {
+                ...(existingEntry?.renderedOutputs ?? {}),
+                [options.pathname]: {
+                    renderedOutputPath: options.renderedOutputPath,
+                    renderedAt: Date.now(),
+                    sourceHash: options.sourceHash,
+                },
+            },
+        };
+        this.persistManifest(manifest);
+    }
+    resetMemory() {
+        this.manifest = undefined;
+        this.manifestLoaded = false;
+    }
+    /**
+     * 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() {
+        if (!this.manifestLoaded && !this.dependencies.exists(this.manifestPath)) {
+            return;
+        }
+        const manifest = createEmptyRouteModuleBuildCacheManifest();
+        this.manifest = manifest;
+        this.manifestLoaded = true;
+        this.persistManifest(manifest);
+    }
+    pruneStaleRenderedOutputs(activePathnames) {
+        if (process.env.NODE_ENV !== 'production') {
+            return [];
+        }
+        const manifest = this.loadManifest();
+        const removedOutputPaths = [];
+        for (const entry of Object.values(manifest.entries)) {
+            if (!entry.renderedOutputs) {
+                continue;
+            }
+            for (const [pathname, renderedOutput] of Object.entries(entry.renderedOutputs)) {
+                if (activePathnames.has(pathname)) {
+                    continue;
+                }
+                removedOutputPaths.push(renderedOutput.renderedOutputPath);
+                delete entry.renderedOutputs[pathname];
+            }
+        }
+        if (removedOutputPaths.length > 0) {
+            this.persistManifest(manifest);
+        }
+        return removedOutputPaths;
     }
-    if (removedOutputPaths.length > 0) {
-      this.persistManifest(manifest);
+    loadManifest() {
+        if (this.manifestLoaded) {
+            return this.manifest ?? createEmptyRouteModuleBuildCacheManifest();
+        }
+        this.manifestLoaded = true;
+        this.manifest = this.dependencies.readManifest(this.manifestPath) ?? createEmptyRouteModuleBuildCacheManifest();
+        return this.manifest;
     }
-    return removedOutputPaths;
-  }
-  loadManifest() {
-    if (this.manifestLoaded) {
-      return this.manifest ?? createEmptyRouteModuleBuildCacheManifest();
+    persistManifest(manifest) {
+        this.manifest = manifest;
+        this.dependencies.writeManifest(this.manifestPath, manifest);
     }
-    this.manifestLoaded = true;
-    this.manifest = this.dependencies.readManifest(this.manifestPath) ?? createEmptyRouteModuleBuildCacheManifest();
-    return this.manifest;
-  }
-  persistManifest(manifest) {
-    this.manifest = manifest;
-    this.dependencies.writeManifest(this.manifestPath, manifest);
-  }
 }
-export {
-  RouteModuleBuildCache
-};

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

@@ -1,8 +1,8 @@
-import type { EcoBuildPlugin } from '../../build/build-types.js';
+import type { BuildOptions } from '../../build/contracts/build-contracts.js';
 import type { PageModuleBuildImportOptions } from './page-module-import.service.js';
 import type { RouteModuleDependencyHashes } from './route-module-dependency-hasher.js';
-/** Filename written beside transpiled server modules that stores incremental build metadata. */
-export declare const ROUTE_MODULE_BUILD_CACHE_FILENAME = ".build-cache.json";
+export { createJsxCacheKey, createPluginCacheKey, getCorePackageVersion, hashPluginSetup, } from '../../build/cache/cache-keys.js';
+export { ROUTE_MODULE_BUILD_CACHE_FILENAME } from '../../build/cache/cache-constants.js';
 /** One persisted route-module build entry in {@link ROUTE_MODULE_BUILD_CACHE_FILENAME}. */
 export interface RouteModuleBuildCacheEntry {
     sourceHash: string;
@@ -20,7 +20,7 @@ export interface RouteModuleStaticRenderCacheEntry {
 }
 /** On-disk manifest describing all cached route-module builds for one server outdir. */
 export interface RouteModuleBuildCacheManifest {
-    invalidationVersion: string;
+    corePackageVersion: string;
     configHash?: string;
     buildInputsFingerprint?: string;
     entries: Record<string, RouteModuleBuildCacheEntry>;
@@ -37,25 +37,21 @@ export interface RouteModuleStaticRenderCacheContext {
 }
 export type RouteModuleBuildCacheManifestReader = (manifestPath: string) => RouteModuleBuildCacheManifest | undefined;
 export type RouteModuleBuildCacheManifestWriter = (manifestPath: string, manifest: RouteModuleBuildCacheManifest) => void;
-/** Returns the installed `@ecopages/core` package version used to invalidate persisted caches. */
-export declare function getCorePackageVersion(): string;
 /** Normalizes filesystem paths used as manifest keys and build-key inputs. */
 export declare function normalizeRouteModuleCachePath(filePath: string): string;
-/** Returns whether route-module disk caching should run for the current import. */
+/**
+ * Returns whether route-module disk caching should run for the current import.
+ */
 export declare function shouldPersistRouteModuleBuildCache(options: PageModuleBuildImportOptions): boolean;
+/** Canonical reuse identity for route-module memory and disk caches. */
+export declare function createRouteModuleReuseIdentity(options: PageModuleBuildImportOptions, sourceTransforms?: BuildOptions['sourceTransforms']): string;
 /** Derives the deterministic on-disk filename for one transpiled route module. */
 export declare function resolvePageModuleOutputFileName(options: {
     filePath: string;
     fileHash: string;
-    cacheScope?: string;
-    invalidationVersion?: number;
 }): string;
 /** Builds the cache key for persisted production route-module builds. */
-export declare function createPersistedRouteModuleBuildKey(options: PageModuleBuildImportOptions): string;
+export declare function createPersistedRouteModuleBuildKey(options: PageModuleBuildImportOptions, sourceTransforms?: BuildOptions['sourceTransforms']): string;
 export declare function createEmptyRouteModuleBuildCacheManifest(): RouteModuleBuildCacheManifest;
 export declare function readRouteModuleBuildCacheManifest(manifestPath: string): RouteModuleBuildCacheManifest | undefined;
 export declare function writeRouteModuleBuildCacheManifest(manifestPath: string, manifest: RouteModuleBuildCacheManifest): void;
-export declare function createJsxCacheKey(jsx: PageModuleBuildImportOptions['jsx']): string;
-export declare function createPluginCacheKey(plugins?: EcoBuildPlugin[]): string;
-/** Exported for in-process import caches that must match persisted build keys. */
-export declare function hashPluginSetup(setup: EcoBuildPlugin['setup']): string;

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

@@ -1,124 +1,60 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-const ROUTE_MODULE_BUILD_CACHE_FILENAME = ".build-cache.json";
-let cachedCorePackageVersion;
-function getCorePackageVersion() {
-  if (cachedCorePackageVersion) {
-    return cachedCorePackageVersion;
-  }
-  const packageJsonPath = new URL("../../../package.json", import.meta.url);
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-  cachedCorePackageVersion = packageJson.version ?? "0.0.0";
-  return cachedCorePackageVersion;
-}
-function normalizeRouteModuleCachePath(filePath) {
-  return path.resolve(filePath);
-}
-function shouldPersistRouteModuleBuildCache(options) {
-  if (process.env.NODE_ENV !== "production") {
-    return false;
-  }
-  if (options.bypassCache) {
-    return false;
-  }
-  if ((options.invalidationVersion ?? 0) > 0) {
-    return false;
-  }
-  if (options.cacheScope) {
-    return false;
-  }
-  return true;
-}
-function resolvePageModuleOutputFileName(options) {
-  const fileBaseName = path.basename(options.filePath, path.extname(options.filePath));
-  const cacheScopeSuffix = options.cacheScope ? `-${sanitizeCacheScope(options.cacheScope)}` : "";
-  const invalidationSuffix = shouldVersionBuildOutputPath(options.invalidationVersion ?? 0) ? `-v${options.invalidationVersion}` : "";
-  return `${fileBaseName}-${options.fileHash}${cacheScopeSuffix}${invalidationSuffix}.mjs`;
-}
-function createPersistedRouteModuleBuildKey(options) {
-  return [
-    path.resolve(options.rootDir),
-    path.resolve(options.outdir),
-    options.splitting ?? "default",
-    options.externalPackages ?? "default",
-    createJsxCacheKey(options.jsx),
-    createPluginCacheKey(options.plugins)
-  ].join("::");
-}
-function createEmptyRouteModuleBuildCacheManifest() {
-  return {
-    invalidationVersion: getCorePackageVersion(),
-    entries: {}
-  };
-}
-function readRouteModuleBuildCacheManifest(manifestPath) {
-  if (!fileSystem.exists(manifestPath)) {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(fileSystem.readFileSync(manifestPath));
-    if (!parsed || typeof parsed !== "object" || typeof parsed.entries !== "object") {
-      return void 0;
+import path from 'node:path';
+import { readProductionCacheManifest, writeProductionCacheManifest } from '../../build/cache/production-build-cache.js';
+import { createJsxCacheKey, createPluginCacheKey, createSourceTransformCacheKey, getCorePackageVersion, } from '../../build/cache/cache-keys.js';
+export { createJsxCacheKey, createPluginCacheKey, getCorePackageVersion, hashPluginSetup, } from '../../build/cache/cache-keys.js';
+export { ROUTE_MODULE_BUILD_CACHE_FILENAME } from '../../build/cache/cache-constants.js';
+/** Normalizes filesystem paths used as manifest keys and build-key inputs. */
+export function normalizeRouteModuleCachePath(filePath) {
+    return path.resolve(filePath);
+}
+/**
+ * Returns whether route-module disk caching should run for the current import.
+ */
+export function shouldPersistRouteModuleBuildCache(options) {
+    if (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'development') {
+        return false;
     }
+    return !options.bypassCache;
+}
+/** Canonical reuse identity for route-module memory and disk caches. */
+export function createRouteModuleReuseIdentity(options, sourceTransforms) {
+    return [
+        path.resolve(options.rootDir),
+        path.resolve(options.outdir),
+        options.splitting ?? 'default',
+        options.externalPackages ?? 'default',
+        createJsxCacheKey(options.jsx),
+        createPluginCacheKey(options.plugins),
+        createSourceTransformCacheKey(sourceTransforms),
+    ].join('::');
+}
+/** Derives the deterministic on-disk filename for one transpiled route module. */
+export function resolvePageModuleOutputFileName(options) {
+    const fileBaseName = path.basename(options.filePath, path.extname(options.filePath));
+    return `${fileBaseName}-${options.fileHash}.mjs`;
+}
+/** Builds the cache key for persisted production route-module builds. */
+export function createPersistedRouteModuleBuildKey(options, sourceTransforms) {
+    return createRouteModuleReuseIdentity(options, sourceTransforms);
+}
+export function createEmptyRouteModuleBuildCacheManifest() {
     return {
-      invalidationVersion: parsed.invalidationVersion ?? "",
-      configHash: parsed.configHash,
-      buildInputsFingerprint: parsed.buildInputsFingerprint,
-      entries: parsed.entries
+        corePackageVersion: getCorePackageVersion(),
+        entries: {},
     };
-  } catch {
-    return void 0;
-  }
-}
-function writeRouteModuleBuildCacheManifest(manifestPath, manifest) {
-  fileSystem.write(manifestPath, `${JSON.stringify(manifest, null, "	")}
-`);
 }
-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}:${hashPluginSetup(plugin.setup)}`).join(",")}`;
+export function readRouteModuleBuildCacheManifest(manifestPath) {
+    const parsed = readProductionCacheManifest(manifestPath);
+    if (!parsed || typeof parsed.entries !== 'object') {
+        return undefined;
+    }
+    return {
+        corePackageVersion: parsed.corePackageVersion ?? parsed.invalidationVersion ?? '',
+        configHash: parsed.configHash,
+        buildInputsFingerprint: parsed.buildInputsFingerprint,
+        entries: parsed.entries,
+    };
 }
-function hashPluginSetup(setup) {
-  let hash = 0;
-  const source = setup.toString();
-  for (let index = 0; index < source.length; index += 1) {
-    hash = hash * 31 + source.charCodeAt(index) | 0;
-  }
-  return (hash >>> 0).toString(36);
+export function writeRouteModuleBuildCacheManifest(manifestPath, manifest) {
+    writeProductionCacheManifest(manifestPath, manifest);
 }
-export {
-  ROUTE_MODULE_BUILD_CACHE_FILENAME,
-  createEmptyRouteModuleBuildCacheManifest,
-  createJsxCacheKey,
-  createPersistedRouteModuleBuildKey,
-  createPluginCacheKey,
-  getCorePackageVersion,
-  hashPluginSetup,
-  normalizeRouteModuleCachePath,
-  readRouteModuleBuildCacheManifest,
-  resolvePageModuleOutputFileName,
-  shouldPersistRouteModuleBuildCache,
-  writeRouteModuleBuildCacheManifest
-};

package/src/services/module-loading/route-module-dependency-hasher.d.ts

@@ -50,8 +50,8 @@ export declare class RouteModuleDependencyHasher {
      * @returns `true` when all stored hashes are present and still valid.
      */
     matchesStoredHashes(storedHashes: RouteModuleDependencyHashes | undefined, entrypointPath?: string, entrypointSourceHash?: string): boolean;
-    /** Clears the per-build memo. Intended for unit tests only. */
-    clearMemoForTests(): void;
+    /** Clears the per-build memo so subsequent reads reflect current file contents. */
+    clearMemo(): void;
 }
 /**
  * Returns whether a bundler module id should participate in route-module cache invalidation.