@ecopages/core 0.2.0-beta.3 → 0.2.0-beta.30

package/src/build/cache/build-input-fingerprint.js

@@ -0,0 +1,31 @@
+import { fileSystem } from "@ecopages/file-system";
+function didBuildInputContributorChange(contributor) {
+  return contributor.didChange?.() === true;
+}
+function hashAppConfigFile(appConfig) {
+  const configPath = appConfig.absolutePaths?.config;
+  if (!configPath || !fileSystem.exists(configPath)) {
+    return "missing";
+  }
+  return fileSystem.hash(configPath);
+}
+function createBuildInputsFingerprint(appConfig) {
+  const changedContributors = [
+    ...Array.from(appConfig.processors?.values() ?? []).filter((processor) => didBuildInputContributorChange(processor)).map((processor) => `processor:${processor.getName()}`),
+    ...(appConfig.integrations ?? []).filter((integration) => didBuildInputContributorChange(integration)).map((integration) => `integration:${integration.name}`)
+  ];
+  return changedContributors.length > 0 ? changedContributors.sort().join("|") : "stable";
+}
+function haveBuildInputsChanged(appConfig) {
+  return createBuildInputsFingerprint(appConfig) !== "stable";
+}
+function collectBuildInputContributors(appConfig) {
+  return [...Array.from(appConfig.processors?.values() ?? []), ...appConfig.integrations ?? []];
+}
+export {
+  collectBuildInputContributors,
+  createBuildInputsFingerprint,
+  didBuildInputContributorChange,
+  hashAppConfigFile,
+  haveBuildInputsChanged
+};

package/src/build/cache/cache-constants.d.ts

@@ -0,0 +1,4 @@
+/** Filename written beside persisted production build artifacts that store incremental metadata. */
+export declare const ROUTE_MODULE_BUILD_CACHE_FILENAME = ".build-cache.json";
+/** @deprecated Use {@link ROUTE_MODULE_BUILD_CACHE_FILENAME}; server-entry caches share the same filename. */
+export declare const SERVER_ENTRY_BUILD_CACHE_FILENAME = ".build-cache.json";

package/src/build/cache/cache-constants.js

@@ -0,0 +1,6 @@
+const ROUTE_MODULE_BUILD_CACHE_FILENAME = ".build-cache.json";
+const SERVER_ENTRY_BUILD_CACHE_FILENAME = ROUTE_MODULE_BUILD_CACHE_FILENAME;
+export {
+  ROUTE_MODULE_BUILD_CACHE_FILENAME,
+  SERVER_ENTRY_BUILD_CACHE_FILENAME
+};

package/src/build/cache/cache-keys.d.ts

@@ -0,0 +1,22 @@
+import type { EcoBuildPlugin } from '../contracts/build-types.js';
+import type { BuildOptions } from '../contracts/build-contracts.js';
+/**
+ * Returns the installed `@ecopages/core` package version for cache invalidation.
+ */
+export declare function getCorePackageVersion(): string;
+/** Stable fingerprint for JSX options used in build and disk cache keys. */
+export declare function createJsxCacheKey(jsx: BuildOptions['jsx']): string;
+/** Stable fingerprint for ordered build plugins. */
+export declare function createPluginCacheKey(plugins?: EcoBuildPlugin[]): string;
+/** Stable fingerprint for ordered source transforms. */
+export declare function createSourceTransformCacheKey(sourceTransforms: BuildOptions['sourceTransforms']): string;
+/**
+ * Stable fingerprint of a function body for cache and request identity keys.
+ *
+ * @remarks
+ * Hashes `fn.toString()`. Suitable for in-process and persisted keys that must
+ * agree within one install; not stable across minifiers or renames.
+ */
+export declare function hashFunctionIdentity(fn: (...args: never[]) => unknown): string;
+/** @deprecated Use {@link hashFunctionIdentity}. */
+export declare const hashPluginSetup: typeof hashFunctionIdentity;

package/src/build/cache/cache-keys.js

@@ -0,0 +1,63 @@
+import { readFileSync } from "node:fs";
+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 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}:${hashFunctionIdentity(plugin.setup)}`).join(",")}`;
+}
+function createSourceTransformCacheKey(sourceTransforms) {
+  if (!sourceTransforms || sourceTransforms.length === 0) {
+    return "sourceTransforms:default";
+  }
+  return `sourceTransforms:${sourceTransforms.map((transform) => {
+    const filterSource = transform.filter.source;
+    const filterFlags = transform.filter.flags;
+    return [
+      transform.name,
+      transform.enforce ?? "default",
+      filterSource,
+      filterFlags,
+      hashFunctionIdentity(transform.transform)
+    ].join(":");
+  }).join(",")}`;
+}
+function hashFunctionIdentity(fn) {
+  let hash = 0;
+  const source = fn.toString();
+  for (let index = 0; index < source.length; index += 1) {
+    hash = hash * 31 + source.charCodeAt(index) | 0;
+  }
+  return (hash >>> 0).toString(36);
+}
+const hashPluginSetup = hashFunctionIdentity;
+export {
+  createJsxCacheKey,
+  createPluginCacheKey,
+  createSourceTransformCacheKey,
+  getCorePackageVersion,
+  hashFunctionIdentity,
+  hashPluginSetup
+};

package/src/build/cache/dev-browser-script-cache.d.ts

@@ -0,0 +1,34 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { ProcessedAsset } from '../../services/assets/asset-processing-service/assets.types.js';
+export declare const DEV_BROWSER_SCRIPT_CACHE_DIR = ".browser-script-bundles";
+export declare const DEV_BROWSER_SCRIPT_CACHE_FILENAME = ".build-cache.json";
+/** Output path restored from the dev disk cache before dependency metadata is merged. */
+export type DevBrowserScriptCacheHit = {
+    filepath: string;
+};
+/**
+ * @remarks
+ * Dev asset caching spans three scopes that should not be conflated:
+ * - request dedupe (`request-build-dedupe.ts`) — one in-flight build per request key
+ * - in-memory service cache (`AssetProcessingService`) — per-process reuse within one dev server
+ * - this disk manifest (`.eco/.browser-script-bundles`) — cross-request reuse of content-script bundles
+ *
+ * Disk entries intentionally store only output file paths. Declarative fields such as
+ * `groupedBundle`, `attributes`, and `packageRole` live on the originating
+ * `ContentScriptAsset` and are merged via `materializeContentScriptAsset()` on lookup.
+ */
+export interface DevBrowserScriptCacheEntry {
+    filepath: string;
+    builtAt: number;
+}
+export interface DevBrowserScriptCacheManifest {
+    invalidationVersion: string;
+    buildInputsFingerprint: string;
+    entries: Record<string, DevBrowserScriptCacheEntry>;
+}
+/** Returns whether dev-only cross-request content-script bundle cache is active. */
+export declare function shouldUseDevBrowserScriptCache(): boolean;
+/** Looks up one persisted dev content-script output path by dependency cache key. */
+export declare function getDevBrowserScriptCacheEntry(appConfig: EcoPagesAppConfig, depKey: string): DevBrowserScriptCacheHit | null;
+/** Persists one dev content-script bundle output for cross-request reuse. */
+export declare function setDevBrowserScriptCacheEntry(appConfig: EcoPagesAppConfig, depKey: string, asset: ProcessedAsset): void;

package/src/build/cache/dev-browser-script-cache.js

@@ -0,0 +1,90 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { getAppBrowserBuildPlugins } from "../build-adapter.js";
+import { createBuildInputsFingerprint, hashAppConfigFile } from "./build-input-fingerprint.js";
+import {
+  readProductionCacheManifest,
+  writeProductionCacheManifest,
+  isProductionCacheManifestCurrent,
+  matchesProductionCacheFingerprint
+} from "./production-build-cache.js";
+import { getCorePackageVersion } from "./cache-keys.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
+import { isDevelopmentRuntime } from "../../utils/runtime.js";
+const DEV_BROWSER_SCRIPT_CACHE_DIR = ".browser-script-bundles";
+const DEV_BROWSER_SCRIPT_CACHE_FILENAME = ".build-cache.json";
+function getDevBrowserScriptCacheDir(appConfig) {
+  return path.join(resolveInternalExecutionDir(appConfig), DEV_BROWSER_SCRIPT_CACHE_DIR);
+}
+function getDevBrowserScriptCacheManifestPath(appConfig) {
+  return path.join(getDevBrowserScriptCacheDir(appConfig), DEV_BROWSER_SCRIPT_CACHE_FILENAME);
+}
+function createBrowserBuildKey(appConfig) {
+  try {
+    const pluginNames = getAppBrowserBuildPlugins(appConfig).map((plugin) => plugin.name).sort().join("|");
+    return pluginNames || "default";
+  } catch {
+    return "default";
+  }
+}
+function createDevBrowserScriptCacheInvalidationVersion(appConfig) {
+  return [getCorePackageVersion(), hashAppConfigFile(appConfig), createBrowserBuildKey(appConfig)].join("::");
+}
+function readManifest(appConfig) {
+  const manifest = readProductionCacheManifest(
+    getDevBrowserScriptCacheManifestPath(appConfig)
+  );
+  if (!manifest) {
+    return void 0;
+  }
+  const invalidationVersion = createDevBrowserScriptCacheInvalidationVersion(appConfig);
+  const buildInputsFingerprint = createBuildInputsFingerprint(appConfig);
+  if (!isProductionCacheManifestCurrent(manifest, invalidationVersion) || !matchesProductionCacheFingerprint(manifest, buildInputsFingerprint)) {
+    return void 0;
+  }
+  return manifest;
+}
+function writeManifest(appConfig, manifest) {
+  writeProductionCacheManifest(getDevBrowserScriptCacheManifestPath(appConfig), manifest);
+}
+function shouldUseDevBrowserScriptCache() {
+  return isDevelopmentRuntime();
+}
+function getDevBrowserScriptCacheEntry(appConfig, depKey) {
+  if (!shouldUseDevBrowserScriptCache()) {
+    return null;
+  }
+  const manifest = readManifest(appConfig);
+  const entry = manifest?.entries[depKey];
+  if (!entry?.filepath || !fileSystem.exists(entry.filepath)) {
+    return null;
+  }
+  return { filepath: entry.filepath };
+}
+function setDevBrowserScriptCacheEntry(appConfig, depKey, asset) {
+  if (!shouldUseDevBrowserScriptCache() || !asset.filepath) {
+    return;
+  }
+  const invalidationVersion = createDevBrowserScriptCacheInvalidationVersion(appConfig);
+  const buildInputsFingerprint = createBuildInputsFingerprint(appConfig);
+  const existing = readManifest(appConfig);
+  const manifest = existing ?? {
+    invalidationVersion,
+    buildInputsFingerprint,
+    entries: {}
+  };
+  manifest.invalidationVersion = invalidationVersion;
+  manifest.buildInputsFingerprint = buildInputsFingerprint;
+  manifest.entries[depKey] = {
+    filepath: asset.filepath,
+    builtAt: Date.now()
+  };
+  writeManifest(appConfig, manifest);
+}
+export {
+  DEV_BROWSER_SCRIPT_CACHE_DIR,
+  DEV_BROWSER_SCRIPT_CACHE_FILENAME,
+  getDevBrowserScriptCacheEntry,
+  setDevBrowserScriptCacheEntry,
+  shouldUseDevBrowserScriptCache
+};

package/src/build/cache/pages-unified-graph-build.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Unified pages Rolldown graph (Phase A build + Phase C import).
+ *
+ * Enabled by default in production builds. Opt out with
+ * `ECOPAGES_UNIFIED_PAGES_GRAPH=0`. Covers all static page template extensions
+ * registered on the app config.
+ */
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+export declare const PAGES_UNIFIED_GRAPH_CACHE_DIR = ".server-pages-graph";
+export declare const PAGES_UNIFIED_GRAPH_CACHE_FILENAME = ".build-cache.json";
+export interface PagesUnifiedGraphCacheManifest {
+    invalidationVersion: string;
+    buildInputsFingerprint: string;
+    buildKey: string;
+    builtAt: number;
+    outputs: Record<string, string>;
+}
+export declare function isPagesUnifiedGraphEnabled(): boolean;
+/** True when the unified graph should build or serve prebuilt page modules. */
+export declare function shouldBuildPagesUnifiedGraph(): boolean;
+export declare function isPagesUnifiedGraphPage(filePath: string, appConfig: EcoPagesAppConfig): boolean;
+/**
+ * Builds eligible static pages in one Rolldown invocation and seeds route-module disk cache.
+ */
+export declare function ensurePagesUnifiedGraphBuilt(options: {
+    appConfig: EcoPagesAppConfig;
+    entryPaths: readonly string[];
+    outdir: string;
+    force?: boolean;
+}): Promise<PagesUnifiedGraphCacheManifest | undefined>;
+export declare function importPagesUnifiedGraphModule<T>(appConfig: EcoPagesAppConfig, filePath: string): Promise<T | undefined>;

package/src/build/cache/pages-unified-graph-build.js

@@ -0,0 +1,198 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fileSystem } from "@ecopages/file-system";
+import { appLogger } from "../../global/app-logger.js";
+import { build } from "../build-adapter.js";
+import { requireBuildRuntime } from "../runtime/build-runtime.js";
+import { createServerBuildRequest, resolveServerAppBuildPlugins } from "../runtime/build-request-policy.js";
+import { createBuildInputsFingerprint, hashAppConfigFile } from "./build-input-fingerprint.js";
+import {
+  isProductionCacheManifestCurrent,
+  matchesProductionCacheBuildKey,
+  matchesProductionCacheFingerprint,
+  readProductionCacheManifest,
+  writeProductionCacheManifest
+} from "./production-build-cache.js";
+import { getCorePackageVersion } from "./cache-keys.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
+import { getSharedRouteModuleBuildCache } from "../../services/module-loading/route-module-build-cache-registry.js";
+import { resolveRouteModuleDependencyPaths } from "../../services/module-loading/route-module-dependency-hasher.js";
+const PAGES_UNIFIED_GRAPH_CACHE_DIR = ".server-pages-graph";
+const PAGES_UNIFIED_GRAPH_CACHE_FILENAME = ".build-cache.json";
+function isPagesUnifiedGraphEnabled() {
+  if (process.env.ECOPAGES_UNIFIED_PAGES_GRAPH === "0") {
+    return false;
+  }
+  if (process.env.ECOPAGES_UNIFIED_PAGES_GRAPH === "1") {
+    return true;
+  }
+  return process.env.NODE_ENV === "production";
+}
+function shouldBuildPagesUnifiedGraph() {
+  return isPagesUnifiedGraphEnabled() && process.env.NODE_ENV === "production";
+}
+function isPagesUnifiedGraphPage(filePath, appConfig) {
+  const normalizedPath = path.normalize(filePath);
+  return appConfig.templatesExt.some((extension) => normalizedPath.endsWith(extension));
+}
+function getPagesUnifiedGraphCachePath(appConfig) {
+  return path.join(
+    resolveInternalExecutionDir(appConfig),
+    PAGES_UNIFIED_GRAPH_CACHE_DIR,
+    PAGES_UNIFIED_GRAPH_CACHE_FILENAME
+  );
+}
+function createPagesUnifiedGraphBuildKey(appConfig, outdir) {
+  const pluginNames = resolveServerAppBuildPlugins(appConfig).map((plugin) => plugin.name).sort().join("|");
+  const templateExtensions = [...appConfig.templatesExt].sort().join("|");
+  return [
+    path.resolve(outdir),
+    hashAppConfigFile(appConfig),
+    templateExtensions,
+    pluginNames,
+    "es2022",
+    "esm",
+    "external-packages"
+  ].join("::");
+}
+function readPagesUnifiedGraphManifest(appConfig) {
+  const manifest = readProductionCacheManifest(
+    getPagesUnifiedGraphCachePath(appConfig)
+  );
+  if (!manifest?.outputs) {
+    return void 0;
+  }
+  return manifest;
+}
+function writePagesUnifiedGraphManifest(appConfig, manifest) {
+  writeProductionCacheManifest(getPagesUnifiedGraphCachePath(appConfig), manifest);
+}
+function createSafeGraphEntryKey(entryPath, rootDir) {
+  const relativePath = path.relative(rootDir, entryPath).replace(/\.[^.]+$/u, "");
+  const safeKey = relativePath.replace(/[^a-zA-Z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
+  return safeKey.length > 0 ? safeKey : "page";
+}
+function resolveOutputForEntrypoint(entryPath, entryKey, buildResult) {
+  const exactOutput = buildResult.entryOutputs?.[path.resolve(entryPath)];
+  if (exactOutput) {
+    return exactOutput;
+  }
+  for (const { path: outputPath } of buildResult.outputs) {
+    const outputBaseName = path.basename(outputPath);
+    if (outputBaseName.startsWith(`${entryKey}-`) && /\.(?:m?js)$/u.test(outputBaseName)) {
+      return outputPath;
+    }
+    if (outputBaseName === `${entryKey}.js` || outputBaseName === `${entryKey}.mjs`) {
+      return outputPath;
+    }
+  }
+  return void 0;
+}
+function isManifestValidForEntries(manifest, appConfig, outdir, entryPaths) {
+  if (!isProductionCacheManifestCurrent(manifest, getCorePackageVersion())) {
+    return false;
+  }
+  if (!matchesProductionCacheFingerprint(manifest, createBuildInputsFingerprint(appConfig))) {
+    return false;
+  }
+  if (!matchesProductionCacheBuildKey(manifest, createPagesUnifiedGraphBuildKey(appConfig, outdir))) {
+    return false;
+  }
+  return entryPaths.every((entryPath) => {
+    const resolvedEntryPath = path.resolve(entryPath);
+    const outputPath = manifest.outputs[resolvedEntryPath];
+    return outputPath ? fileSystem.exists(outputPath) : false;
+  });
+}
+async function ensurePagesUnifiedGraphBuilt(options) {
+  if (!shouldBuildPagesUnifiedGraph()) {
+    return void 0;
+  }
+  const eligibleEntryPaths = options.entryPaths.map((entryPath) => path.resolve(entryPath)).filter((entryPath) => isPagesUnifiedGraphPage(entryPath, options.appConfig));
+  if (eligibleEntryPaths.length === 0) {
+    return void 0;
+  }
+  const outdir = path.resolve(options.outdir);
+  const existingManifest = options.force ? void 0 : readPagesUnifiedGraphManifest(options.appConfig);
+  if (existingManifest && isManifestValidForEntries(existingManifest, options.appConfig, outdir, eligibleEntryPaths)) {
+    appLogger.debug("Reusing pages unified graph cache");
+    return existingManifest;
+  }
+  const routeModuleBuildCache = getSharedRouteModuleBuildCache(outdir, options.appConfig);
+  const entryRecord = {};
+  const entryKeysByPath = /* @__PURE__ */ new Map();
+  for (const entryPath of eligibleEntryPaths) {
+    const entryKey = createSafeGraphEntryKey(entryPath, options.appConfig.rootDir);
+    entryRecord[entryKey] = entryPath;
+    entryKeysByPath.set(entryPath, entryKey);
+  }
+  appLogger.debugTime("pagesUnifiedGraphBuild");
+  const buildOptions = createServerBuildRequest(options.appConfig, {
+    profile: "route-module",
+    entrypoints: entryRecord,
+    outdir,
+    splitting: true,
+    naming: "[name]-[hash].[ext]"
+  });
+  const plugins = buildOptions.plugins ?? [];
+  const buildResult = await build(buildOptions, requireBuildRuntime(options.appConfig).getProfile("route-module"));
+  appLogger.debugTimeEnd("pagesUnifiedGraphBuild");
+  if (!buildResult.success) {
+    const details = buildResult.logs.map((log) => log.message).join(" | ");
+    throw new Error(`Pages unified graph build failed: ${details}`);
+  }
+  const outputs = {};
+  for (const entryPath of eligibleEntryPaths) {
+    const fileHash = fileSystem.hash(entryPath);
+    const entryKey = entryKeysByPath.get(entryPath);
+    const compiledOutput = entryKey ? resolveOutputForEntrypoint(entryPath, entryKey, buildResult) : void 0;
+    if (!compiledOutput) {
+      throw new Error(`Pages unified graph build produced no output for ${entryPath}`);
+    }
+    outputs[entryPath] = compiledOutput;
+    routeModuleBuildCache.recordBuild({
+      filePath: entryPath,
+      rootDir: options.appConfig.rootDir,
+      outdir,
+      fileHash,
+      outputPath: compiledOutput,
+      dependencyModulePaths: resolveRouteModuleDependencyPaths(buildResult, entryPath, options.appConfig.rootDir),
+      externalPackages: true,
+      plugins
+    });
+  }
+  const manifest = {
+    invalidationVersion: getCorePackageVersion(),
+    buildInputsFingerprint: createBuildInputsFingerprint(options.appConfig),
+    buildKey: createPagesUnifiedGraphBuildKey(options.appConfig, outdir),
+    builtAt: Date.now(),
+    outputs
+  };
+  writePagesUnifiedGraphManifest(options.appConfig, manifest);
+  appLogger.debug(`Built pages unified graph for ${eligibleEntryPaths.length} entries`);
+  return manifest;
+}
+async function importPagesUnifiedGraphModule(appConfig, filePath) {
+  const manifest = readPagesUnifiedGraphManifest(appConfig);
+  if (!manifest) {
+    return void 0;
+  }
+  const resolvedFilePath = path.resolve(filePath);
+  const outputPath = manifest.outputs[resolvedFilePath];
+  if (!outputPath || !fileSystem.exists(outputPath)) {
+    return void 0;
+  }
+  return await import(
+    /* @vite-ignore */
+    pathToFileURL(outputPath).href
+  );
+}
+export {
+  PAGES_UNIFIED_GRAPH_CACHE_DIR,
+  PAGES_UNIFIED_GRAPH_CACHE_FILENAME,
+  ensurePagesUnifiedGraphBuilt,
+  importPagesUnifiedGraphModule,
+  isPagesUnifiedGraphEnabled,
+  isPagesUnifiedGraphPage,
+  shouldBuildPagesUnifiedGraph
+};

package/src/build/cache/production-build-cache.d.ts

@@ -0,0 +1,20 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+/**
+ * Shared manifest fields for persisted production build caches.
+ */
+export interface ProductionCacheManifestBase {
+    invalidationVersion: string;
+    buildInputsFingerprint?: string;
+    buildKey?: string;
+    builtAt?: number;
+}
+export type ProductionBuildCacheKind = 'server-entry' | 'route-module' | 'pages-graph';
+/** Returns every persisted production cache manifest path for one app. */
+export declare function getProductionBuildCacheManifestPaths(appConfig: EcoPagesAppConfig): string[];
+/** Removes all persisted production cache manifests for one app. */
+export declare function clearPersistedProductionBuildCacheManifests(appConfig: EcoPagesAppConfig): void;
+export declare function readProductionCacheManifest<T extends ProductionCacheManifestBase>(manifestPath: string): T | undefined;
+export declare function writeProductionCacheManifest(manifestPath: string, manifest: unknown): void;
+export declare function isProductionCacheManifestCurrent(manifest: ProductionCacheManifestBase | undefined, invalidationVersion: string): boolean;
+export declare function matchesProductionCacheFingerprint(manifest: ProductionCacheManifestBase | undefined, buildInputsFingerprint: string): boolean;
+export declare function matchesProductionCacheBuildKey(manifest: ProductionCacheManifestBase | undefined, buildKey: string): boolean;

package/src/build/cache/production-build-cache.js

@@ -0,0 +1,63 @@
+import { fileSystem } from "@ecopages/file-system";
+import path from "node:path";
+import { ROUTE_MODULE_BUILD_CACHE_FILENAME } from "./cache-constants.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
+const ROUTE_MODULE_CACHE_OUTDIRS = [".server-modules", ".server-route-modules"];
+const PAGES_GRAPH_CACHE_DIR = ".server-pages-graph";
+function getProductionBuildCacheManifestPaths(appConfig) {
+  const executionDir = resolveInternalExecutionDir(appConfig);
+  const paths = [];
+  for (const subdir of ROUTE_MODULE_CACHE_OUTDIRS) {
+    paths.push(path.join(executionDir, subdir, ROUTE_MODULE_BUILD_CACHE_FILENAME));
+  }
+  paths.push(path.join(executionDir, ".server-entry", ROUTE_MODULE_BUILD_CACHE_FILENAME));
+  paths.push(path.join(executionDir, PAGES_GRAPH_CACHE_DIR, ROUTE_MODULE_BUILD_CACHE_FILENAME));
+  return paths;
+}
+function clearPersistedProductionBuildCacheManifests(appConfig) {
+  if (process.env.NODE_ENV !== "production") {
+    return;
+  }
+  for (const manifestPath of getProductionBuildCacheManifestPaths(appConfig)) {
+    if (fileSystem.exists(manifestPath)) {
+      fileSystem.remove(manifestPath);
+    }
+  }
+}
+function readProductionCacheManifest(manifestPath) {
+  if (!fileSystem.exists(manifestPath)) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(fileSystem.readFileSync(manifestPath));
+    if (!parsed || typeof parsed !== "object") {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function writeProductionCacheManifest(manifestPath, manifest) {
+  fileSystem.ensureDir(path.dirname(manifestPath));
+  fileSystem.write(manifestPath, `${JSON.stringify(manifest, null, "	")}
+`);
+}
+function isProductionCacheManifestCurrent(manifest, invalidationVersion) {
+  return manifest?.invalidationVersion === invalidationVersion;
+}
+function matchesProductionCacheFingerprint(manifest, buildInputsFingerprint) {
+  return manifest?.buildInputsFingerprint === buildInputsFingerprint;
+}
+function matchesProductionCacheBuildKey(manifest, buildKey) {
+  return manifest?.buildKey === buildKey;
+}
+export {
+  clearPersistedProductionBuildCacheManifests,
+  getProductionBuildCacheManifestPaths,
+  isProductionCacheManifestCurrent,
+  matchesProductionCacheBuildKey,
+  matchesProductionCacheFingerprint,
+  readProductionCacheManifest,
+  writeProductionCacheManifest
+};

package/src/build/cache/server-entry-build-cache.d.ts

@@ -0,0 +1,43 @@
+import type { BuildResult } from '../build-adapter.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+export { SERVER_ENTRY_BUILD_CACHE_FILENAME } from './cache-constants.js';
+export declare const SERVER_BUNDLE_MANIFEST_FILENAME = "manifest.json";
+export interface ServerBundleDeployManifest {
+    serverEntry: string;
+    distDir: string;
+    builtAt: number;
+}
+export interface ServerEntryBuildCacheManifest {
+    invalidationVersion: string;
+    entryPath: string;
+    entryHash: string;
+    buildInputsFingerprint: string;
+    buildKey: string;
+    outputPaths: string[];
+    dependencyHashes: Record<string, string>;
+    builtAt: number;
+}
+export interface ServerEntryBuildCacheLookup {
+    manifest: ServerEntryBuildCacheManifest;
+    outputPaths: string[];
+}
+export declare function getServerBundleOutputPaths(appConfig: EcoPagesAppConfig): {
+    distDir: string;
+    serverOutdir: string;
+    serverEntryPath: string;
+    manifestPath: string;
+};
+export declare function readServerEntryBuildCacheManifest(appConfig: EcoPagesAppConfig): ServerEntryBuildCacheManifest | undefined;
+export declare function writeServerBundleDeployManifest(appConfig: EcoPagesAppConfig, serverEntryPath: string): void;
+export declare function lookupServerEntryBuildCache(options: {
+    appConfig: EcoPagesAppConfig;
+    entryPath: string;
+    force?: boolean;
+}): ServerEntryBuildCacheLookup | undefined;
+export declare function recordServerEntryBuildCache(options: {
+    appConfig: EcoPagesAppConfig;
+    entryPath: string;
+    buildResult: BuildResult;
+    outputPaths: string[];
+}): void;
+export declare function resolveProductionServerEntry(cwd?: string): string | undefined;