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

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

@@ -0,0 +1,202 @@
+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 };
+    }
+    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));
+    }
+    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);
+    }
+    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;
+    }
+    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;
+    }
+    loadManifest() {
+        if (this.manifestLoaded) {
+            return this.manifest ?? createEmptyRouteModuleBuildCacheManifest();
+        }
+        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);
+    }
+}

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

@@ -0,0 +1,57 @@
+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';
+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;
+    outputPath: string;
+    builtAt: number;
+    buildKey: string;
+    dependencyHashes?: RouteModuleDependencyHashes;
+    renderedOutputs?: Record<string, RouteModuleStaticRenderCacheEntry>;
+}
+/** Metadata for one rendered static HTML artifact derived from a route module. */
+export interface RouteModuleStaticRenderCacheEntry {
+    renderedOutputPath: string;
+    renderedAt: number;
+    sourceHash: string;
+}
+/** On-disk manifest describing all cached route-module builds for one server outdir. */
+export interface RouteModuleBuildCacheManifest {
+    corePackageVersion: string;
+    configHash?: string;
+    buildInputsFingerprint?: string;
+    entries: Record<string, RouteModuleBuildCacheEntry>;
+}
+/** Successful route-module cache lookup result. */
+export interface RouteModuleBuildCacheLookup {
+    outputPath: string;
+    entry: RouteModuleBuildCacheEntry;
+}
+/** Inputs that must remain stable for incremental static HTML generation. */
+export interface RouteModuleStaticRenderCacheContext {
+    configHash: string;
+    buildInputsFingerprint: string;
+}
+export type RouteModuleBuildCacheManifestReader = (manifestPath: string) => RouteModuleBuildCacheManifest | undefined;
+export type RouteModuleBuildCacheManifestWriter = (manifestPath: string, manifest: RouteModuleBuildCacheManifest) => void;
+/** 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.
+ */
+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;
+}): string;
+/** Builds the cache key for persisted production route-module builds. */
+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;

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

@@ -0,0 +1,60 @@
+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 {
+        corePackageVersion: getCorePackageVersion(),
+        entries: {},
+    };
+}
+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,
+    };
+}
+export function writeRouteModuleBuildCacheManifest(manifestPath, manifest) {
+    writeProductionCacheManifest(manifestPath, manifest);
+}

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

@@ -0,0 +1,81 @@
+import type { BuildResult } from '../../build/build-adapter.js';
+/**
+ * Content hashes for every trackable source file in one route module's import graph.
+ *
+ * @remarks
+ * Keys are normalized absolute filesystem paths. Values are opaque content hashes
+ * produced by the active {@link FileSystem} implementation. Only app-owned source
+ * files are tracked; `node:` builtins and `node_modules` paths are excluded
+ * because they are covered by the core package {@link getCorePackageVersion | invalidation version}.
+ */
+export type RouteModuleDependencyHashes = Record<string, string>;
+type HashFileFn = (filePath: string) => string;
+type ExistsFn = (filePath: string) => boolean;
+/**
+ * Lazily hashes route-module dependency files while memoizing results for one build run.
+ *
+ * @remarks
+ * Multiple route modules often share layouts or utilities. Memoizing per path avoids
+ * re-reading the same dependency file while validating or recording many cache entries
+ * during one production build.
+ */
+export declare class RouteModuleDependencyHasher {
+    private readonly memo;
+    private readonly hashFile;
+    private readonly exists;
+    constructor(dependencies?: {
+        hashFile?: HashFileFn;
+        exists?: ExistsFn;
+    });
+    /**
+     * Returns a memoized content hash for one trackable dependency path.
+     *
+     * @param filePath - Absolute or project-relative source path.
+     * @returns The content hash, or `undefined` when the path is not trackable or missing.
+     */
+    hashDependency(filePath: string): string | undefined;
+    /**
+     * Builds the dependency-hash map for one route entrypoint graph.
+     *
+     * @param modulePaths - Raw module ids from the bundler dependency graph.
+     * @returns Hashes for every trackable, existing source file in the graph.
+     */
+    createDependencyHashes(modulePaths: readonly string[]): RouteModuleDependencyHashes;
+    /**
+     * Returns whether every stored dependency hash still matches the current file contents.
+     *
+     * @param storedHashes - Dependency hashes previously persisted for one route module.
+     * @param entrypointPath - Route entry file whose hash is validated separately.
+     * @param entrypointSourceHash - Already-validated content hash for {@link entrypointPath}.
+     * @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 so subsequent reads reflect current file contents. */
+    clearMemo(): void;
+}
+/**
+ * Returns whether a bundler module id should participate in route-module cache invalidation.
+ *
+ * @remarks
+ * Builtins and installed packages are excluded. Their changes are expected to be
+ * reflected through framework-level invalidation instead of per-route file hashing.
+ */
+export declare function isTrackableRouteModuleDependency(modulePath: string): boolean;
+/**
+ * Filters a bundler module list down to trackable app-owned source files.
+ */
+export declare function filterTrackableRouteModuleDependencies(modulePaths: readonly string[]): string[];
+/**
+ * Resolves the dependency module list for one route entrypoint from a build result.
+ *
+ * @param buildResult - Completed route-module build output.
+ * @param entrypointPath - Absolute or root-relative route source path used as the build entry.
+ * @param rootDir - Project root used to normalize relative module ids.
+ * @returns Normalized module paths, falling back to the entrypoint when no graph is available.
+ */
+export declare function resolveRouteModuleDependencyPaths(buildResult: Pick<BuildResult, 'dependencyGraph'>, entrypointPath: string, rootDir: string): string[];
+/**
+ * Convenience helper that combines graph extraction and dependency hashing.
+ */
+export declare function createRouteModuleDependencyHashes(hasher: RouteModuleDependencyHasher, buildResult: Pick<BuildResult, 'dependencyGraph'>, entrypointPath: string, rootDir: string): RouteModuleDependencyHashes;
+export {};

package/src/services/module-loading/route-module-dependency-hasher.js

@@ -0,0 +1,148 @@
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+/**
+ * Lazily hashes route-module dependency files while memoizing results for one build run.
+ *
+ * @remarks
+ * Multiple route modules often share layouts or utilities. Memoizing per path avoids
+ * re-reading the same dependency file while validating or recording many cache entries
+ * during one production build.
+ */
+export class RouteModuleDependencyHasher {
+    memo = new Map();
+    hashFile;
+    exists;
+    constructor(dependencies) {
+        this.hashFile = dependencies?.hashFile ?? ((filePath) => fileSystem.hash(filePath));
+        this.exists = dependencies?.exists ?? ((filePath) => fileSystem.exists(filePath));
+    }
+    /**
+     * Returns a memoized content hash for one trackable dependency path.
+     *
+     * @param filePath - Absolute or project-relative source path.
+     * @returns The content hash, or `undefined` when the path is not trackable or missing.
+     */
+    hashDependency(filePath) {
+        const normalizedPath = path.normalize(filePath);
+        if (!isTrackableRouteModuleDependency(normalizedPath)) {
+            return undefined;
+        }
+        if (!this.exists(normalizedPath)) {
+            return undefined;
+        }
+        const cachedHash = this.memo.get(normalizedPath);
+        if (cachedHash) {
+            return cachedHash;
+        }
+        const nextHash = this.hashFile(normalizedPath);
+        this.memo.set(normalizedPath, nextHash);
+        return nextHash;
+    }
+    /**
+     * Builds the dependency-hash map for one route entrypoint graph.
+     *
+     * @param modulePaths - Raw module ids from the bundler dependency graph.
+     * @returns Hashes for every trackable, existing source file in the graph.
+     */
+    createDependencyHashes(modulePaths) {
+        const dependencyHashes = {};
+        for (const modulePath of filterTrackableRouteModuleDependencies(modulePaths)) {
+            const dependencyHash = this.hashDependency(modulePath);
+            if (dependencyHash) {
+                dependencyHashes[modulePath] = dependencyHash;
+            }
+        }
+        return dependencyHashes;
+    }
+    /**
+     * Returns whether every stored dependency hash still matches the current file contents.
+     *
+     * @param storedHashes - Dependency hashes previously persisted for one route module.
+     * @param entrypointPath - Route entry file whose hash is validated separately.
+     * @param entrypointSourceHash - Already-validated content hash for {@link entrypointPath}.
+     * @returns `true` when all stored hashes are present and still valid.
+     */
+    matchesStoredHashes(storedHashes, entrypointPath, entrypointSourceHash) {
+        this.clearMemo();
+        if (!storedHashes || Object.keys(storedHashes).length === 0) {
+            return false;
+        }
+        const normalizedEntrypoint = entrypointPath ? path.normalize(entrypointPath) : undefined;
+        for (const [dependencyPath, storedHash] of Object.entries(storedHashes)) {
+            if (normalizedEntrypoint && path.normalize(dependencyPath) === normalizedEntrypoint) {
+                if (entrypointSourceHash && storedHash !== entrypointSourceHash) {
+                    return false;
+                }
+                continue;
+            }
+            const currentHash = this.hashDependency(dependencyPath);
+            if (!currentHash || currentHash !== storedHash) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /** Clears the per-build memo so subsequent reads reflect current file contents. */
+    clearMemo() {
+        this.memo.clear();
+    }
+}
+/**
+ * Returns whether a bundler module id should participate in route-module cache invalidation.
+ *
+ * @remarks
+ * Builtins and installed packages are excluded. Their changes are expected to be
+ * reflected through framework-level invalidation instead of per-route file hashing.
+ */
+export function isTrackableRouteModuleDependency(modulePath) {
+    const normalizedPath = path.normalize(modulePath);
+    if (normalizedPath.startsWith('node:')) {
+        return false;
+    }
+    if (normalizedPath.includes(`${path.sep}node_modules${path.sep}`)) {
+        return false;
+    }
+    return /\.(?:[cm]?[jt]sx?|mdx)$/iu.test(normalizedPath) || normalizedPath.endsWith('.json');
+}
+/**
+ * Filters a bundler module list down to trackable app-owned source files.
+ */
+export function filterTrackableRouteModuleDependencies(modulePaths) {
+    const uniquePaths = new Set();
+    for (const modulePath of modulePaths) {
+        const normalizedPath = path.normalize(modulePath);
+        if (isTrackableRouteModuleDependency(normalizedPath)) {
+            uniquePaths.add(normalizedPath);
+        }
+    }
+    return Array.from(uniquePaths).sort();
+}
+/**
+ * Resolves the dependency module list for one route entrypoint from a build result.
+ *
+ * @param buildResult - Completed route-module build output.
+ * @param entrypointPath - Absolute or root-relative route source path used as the build entry.
+ * @param rootDir - Project root used to normalize relative module ids.
+ * @returns Normalized module paths, falling back to the entrypoint when no graph is available.
+ */
+export function resolveRouteModuleDependencyPaths(buildResult, entrypointPath, rootDir) {
+    const normalizedEntrypoint = path.isAbsolute(entrypointPath)
+        ? path.normalize(entrypointPath)
+        : path.normalize(path.resolve(rootDir, entrypointPath));
+    const graphEntrypoints = buildResult.dependencyGraph?.entrypoints ?? {};
+    const dependencyPaths = graphEntrypoints[normalizedEntrypoint] ??
+        graphEntrypoints[entrypointPath] ??
+        Object.entries(graphEntrypoints).find(([candidate]) => path.normalize(candidate) === normalizedEntrypoint)?.[1];
+    if (!dependencyPaths || dependencyPaths.length === 0) {
+        return [normalizedEntrypoint];
+    }
+    return dependencyPaths.map((dependencyPath) => path.isAbsolute(dependencyPath)
+        ? path.normalize(dependencyPath)
+        : path.normalize(path.resolve(rootDir, dependencyPath)));
+}
+/**
+ * Convenience helper that combines graph extraction and dependency hashing.
+ */
+export function createRouteModuleDependencyHashes(hasher, buildResult, entrypointPath, rootDir) {
+    return hasher.createDependencyHashes(resolveRouteModuleDependencyPaths(buildResult, entrypointPath, rootDir));
+}

package/src/services/module-loading/server-module-transpiler.service.d.ts

@@ -1,5 +1,5 @@
 import type { BuildExecutor } from '../../build/build-adapter.js';
-import type { EcoBuildPlugin } from '../../build/build-types.js';
+import type { EcoBuildPlugin } from '../../build/contracts/build-types.js';
 import type { AppModuleLoader } from './app-module-loader.service.js';
 import { type PageModuleBuildImportOptions } from './page-module-import.service.js';
 import type { SourceModuleLoaderFactory } from './module-loading-types.js';
@@ -18,7 +18,6 @@ export type ServerModuleTranspilerBootstrapArgs = {
     getBuildExecutor?: () => BuildExecutor | undefined;
     canLoadSourceModuleFromHost?: (filePath: string) => boolean;
     getHostModuleLoader?: SourceModuleLoaderFactory;
-    getInvalidationVersion?: () => number;
     invalidateModules?: (changedFiles?: string[]) => void;
     pageModuleImportService?: ServerModuleImportDependency;
     /** Factory evaluated on each importModule call to produce plugins applied to every load. */
@@ -35,7 +34,6 @@ export declare class ServerModuleTranspiler {
     private readonly pageModuleImportService;
     private readonly getRootDir;
     private readonly getBuildExecutor;
-    private readonly getInvalidationVersion;
     private readonly invalidateModules;
     private readonly getDefaultPlugins;
     /**