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

package/src/build/cache/server-entry-build-cache.js

@@ -0,0 +1,165 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { resolveServerAppBuildPlugins } from "../runtime/build-request-policy.js";
+import { createBuildInputsFingerprint } from "./build-input-fingerprint.js";
+import {
+  isProductionCacheManifestCurrent,
+  matchesProductionCacheBuildKey,
+  matchesProductionCacheFingerprint,
+  readProductionCacheManifest,
+  writeProductionCacheManifest
+} from "./production-build-cache.js";
+import { createPluginCacheKey, getCorePackageVersion } from "./cache-keys.js";
+import {
+  RouteModuleDependencyHasher,
+  createRouteModuleDependencyHashes
+} from "../../services/module-loading/route-module-dependency-hasher.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
+import { SERVER_BUNDLE_DIR, SERVER_BUNDLE_FILENAME } from "../../utils/resolve-entry-file.js";
+import { SERVER_ENTRY_BUILD_CACHE_FILENAME } from "./cache-constants.js";
+import { SERVER_ENTRY_BUILD_CACHE_FILENAME as SERVER_ENTRY_BUILD_CACHE_FILENAME2 } from "./cache-constants.js";
+const SERVER_BUNDLE_MANIFEST_FILENAME = "manifest.json";
+function getServerEntryCacheDir(appConfig) {
+  return path.join(resolveInternalExecutionDir(appConfig), ".server-entry");
+}
+function getServerEntryCacheManifestPath(appConfig) {
+  return path.join(getServerEntryCacheDir(appConfig), SERVER_ENTRY_BUILD_CACHE_FILENAME);
+}
+function hashDependencyGraph(entryPath, dependencyGraph, hasher, rootDir) {
+  if (!dependencyGraph) {
+    return { [path.resolve(entryPath)]: fileSystem.hash(entryPath) };
+  }
+  return createRouteModuleDependencyHashes(hasher, { dependencyGraph }, entryPath, rootDir);
+}
+function createServerEntryBuildKey(appConfig) {
+  try {
+    return [
+      "server-entry-request-v2",
+      "node",
+      "esm",
+      "external-packages",
+      createPluginCacheKey(resolveServerAppBuildPlugins(appConfig))
+    ].join("::");
+  } catch {
+    return "server-entry-request-v2::node::esm::external-packages";
+  }
+}
+function getServerBundleOutputPaths(appConfig) {
+  const distDir = appConfig.absolutePaths?.distDir ?? path.join(appConfig.rootDir, appConfig.distDir);
+  const serverOutdir = path.join(distDir, SERVER_BUNDLE_DIR);
+  const serverEntryPath = path.join(serverOutdir, SERVER_BUNDLE_FILENAME);
+  const manifestPath = path.join(serverOutdir, SERVER_BUNDLE_MANIFEST_FILENAME);
+  return { distDir, serverOutdir, serverEntryPath, manifestPath };
+}
+function readServerEntryBuildCacheManifest(appConfig) {
+  return readProductionCacheManifest(getServerEntryCacheManifestPath(appConfig));
+}
+function writeServerEntryBuildCacheManifest(appConfig, manifest) {
+  writeProductionCacheManifest(
+    path.join(getServerEntryCacheDir(appConfig), SERVER_ENTRY_BUILD_CACHE_FILENAME),
+    manifest
+  );
+}
+function writeServerBundleDeployManifest(appConfig, serverEntryPath) {
+  const { distDir, manifestPath } = getServerBundleOutputPaths(appConfig);
+  fileSystem.ensureDir(path.dirname(manifestPath));
+  const payload = {
+    serverEntry: path.relative(path.dirname(manifestPath), serverEntryPath) || SERVER_BUNDLE_FILENAME,
+    distDir,
+    builtAt: Date.now()
+  };
+  fileSystem.write(manifestPath, `${JSON.stringify(payload, null, "	")}
+`);
+}
+function lookupServerEntryBuildCache(options) {
+  if (options.force) {
+    return void 0;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    return void 0;
+  }
+  const entryPath = path.resolve(options.entryPath);
+  const entryHash = fileSystem.hash(entryPath);
+  const buildInputsFingerprint = createBuildInputsFingerprint(options.appConfig);
+  const buildKey = createServerEntryBuildKey(options.appConfig);
+  const manifest = readServerEntryBuildCacheManifest(options.appConfig);
+  if (!manifest) {
+    return void 0;
+  }
+  if (!isProductionCacheManifestCurrent(manifest, getCorePackageVersion())) {
+    return void 0;
+  }
+  if (manifest.entryPath !== entryPath || manifest.entryHash !== entryHash || !matchesProductionCacheFingerprint(manifest, buildInputsFingerprint) || !matchesProductionCacheBuildKey(manifest, buildKey)) {
+    return void 0;
+  }
+  const hasher = new RouteModuleDependencyHasher();
+  if (!hasher.matchesStoredHashes(manifest.dependencyHashes, entryPath, entryHash)) {
+    return void 0;
+  }
+  const existingOutputs = manifest.outputPaths.filter((outputPath) => fileSystem.exists(outputPath));
+  if (existingOutputs.length === 0) {
+    return void 0;
+  }
+  return {
+    manifest,
+    outputPaths: existingOutputs
+  };
+}
+function recordServerEntryBuildCache(options) {
+  if (process.env.NODE_ENV !== "production") {
+    return;
+  }
+  const entryPath = path.resolve(options.entryPath);
+  const entryHash = fileSystem.hash(entryPath);
+  const hasher = new RouteModuleDependencyHasher();
+  const dependencyHashes = hashDependencyGraph(
+    entryPath,
+    options.buildResult.dependencyGraph,
+    hasher,
+    options.appConfig.rootDir
+  );
+  const manifest = {
+    invalidationVersion: getCorePackageVersion(),
+    entryPath,
+    entryHash,
+    buildInputsFingerprint: createBuildInputsFingerprint(options.appConfig),
+    buildKey: createServerEntryBuildKey(options.appConfig),
+    outputPaths: options.outputPaths,
+    dependencyHashes,
+    builtAt: Date.now()
+  };
+  writeServerEntryBuildCacheManifest(options.appConfig, manifest);
+}
+function resolveProductionServerEntry(cwd = process.cwd()) {
+  const manifestPath = path.join(cwd, "dist", SERVER_BUNDLE_DIR, SERVER_BUNDLE_MANIFEST_FILENAME);
+  if (fileSystem.exists(manifestPath)) {
+    try {
+      const parsed = JSON.parse(fileSystem.readFileSync(manifestPath));
+      if (parsed?.serverEntry) {
+        const fromManifest = path.isAbsolute(parsed.serverEntry) ? parsed.serverEntry : path.join(path.dirname(manifestPath), parsed.serverEntry);
+        if (fileSystem.exists(fromManifest)) {
+          return fromManifest;
+        }
+      }
+      if (parsed?.distDir) {
+        const fromDistDir = path.join(parsed.distDir, SERVER_BUNDLE_DIR, SERVER_BUNDLE_FILENAME);
+        if (fileSystem.exists(fromDistDir)) {
+          return fromDistDir;
+        }
+      }
+    } catch {
+    }
+  }
+  const legacyPath = path.join(cwd, "dist", SERVER_BUNDLE_DIR, SERVER_BUNDLE_FILENAME);
+  return fileSystem.exists(legacyPath) ? legacyPath : void 0;
+}
+export {
+  SERVER_BUNDLE_MANIFEST_FILENAME,
+  SERVER_ENTRY_BUILD_CACHE_FILENAME2 as SERVER_ENTRY_BUILD_CACHE_FILENAME,
+  getServerBundleOutputPaths,
+  lookupServerEntryBuildCache,
+  readServerEntryBuildCacheManifest,
+  recordServerEntryBuildCache,
+  resolveProductionServerEntry,
+  writeServerBundleDeployManifest
+};

package/src/build/contracts/build-contracts.d.ts

@@ -0,0 +1,96 @@
+import type { EcoSourceTransform } from '../../plugins/source-transform.js';
+import type { EcoBuildPlugin } from './build-types.js';
+/**
+ * Which backend owns the app's build pipeline.
+ *
+ * - `'rolldown'`: the default. Ecopages runs the build directly through
+ *   its bundler-backed adapter.
+ * - `'vite-host'`: a host runtime owns the build. {@link ViteHostBuildAdapter}
+ *   is exposed as a boundary marker; any direct call into it throws.
+ */
+export type BuildOwnership = 'vite-host' | 'rolldown';
+/** A single message emitted by the build backend. */
+export interface BuildLog {
+    message: string;
+}
+/** A single artifact emitted by the build backend. */
+export interface BuildOutput {
+    path: string;
+}
+/** Per-entrypoint dependency metadata surfaced alongside a build. */
+export interface BuildDependencyGraph {
+    entrypoints: Record<string, string[]>;
+}
+/** The full result of one `BuildAdapter.build` call. */
+export interface BuildResult {
+    success: boolean;
+    logs: BuildLog[];
+    outputs: BuildOutput[];
+    dependencyGraph?: BuildDependencyGraph;
+    entryOutputs?: Record<string, string>;
+}
+/**
+ * Options accepted by every `BuildAdapter.build` call.
+ *
+ * @remarks
+ * Fields that the adapter can forward are honored; fields that cannot
+ * (currently `splitting`, `bundle`, and `outbase`) are accepted so
+ * call-sites compile, but the adapter ignores them.
+ */
+export interface BuildOptions {
+    entrypoints: string[] | Record<string, string>;
+    outdir?: string;
+    /**
+     * Base directory for `[dir]` placeholders in `naming`. Currently
+     * the bundled adapter derives the base from `root` directly and
+     * ignores this field.
+     *
+     * @deprecated Accepted for call-site compatibility only. Use record-form
+     * `entrypoints` keys to preserve directory structure.
+     */
+    outbase?: string;
+    naming?: string;
+    conditions?: string[];
+    define?: Record<string, string>;
+    minify?: boolean;
+    treeshaking?: boolean;
+    target?: string;
+    format?: string;
+    sourcemap?: string;
+    /** @deprecated Accepted for call-site compatibility only. */
+    splitting?: boolean;
+    root?: string;
+    /** @deprecated Accepted for call-site compatibility only. */
+    bundle?: boolean;
+    externalPackages?: boolean;
+    external?: string[];
+    jsx?: {
+        development?: boolean;
+        factory?: string;
+        fragment?: string;
+        importSource?: string;
+        runtime?: 'classic' | 'automatic';
+        sideEffects?: boolean;
+    };
+    plugins?: EcoBuildPlugin[];
+    sourceTransforms?: EcoSourceTransform[];
+}
+/** Stable profile identifiers for `BuildAdapter.getTranspileOptions`. */
+export type BuildTranspileProfile = 'browser-script' | 'hmr-runtime' | 'hmr-entrypoint';
+/** Resolved transpile settings for a given profile. */
+export interface BuildTranspileOptions {
+    target: string;
+    format: string;
+    sourcemap: string;
+}
+/** Low-level build backend contract. */
+export interface BuildAdapter {
+    readonly ownership?: BuildOwnership;
+    build(options: BuildOptions): Promise<BuildResult>;
+    resolve(importPath: string, rootDir: string): string;
+    getTranspileOptions(profile: BuildTranspileProfile): BuildTranspileOptions;
+}
+/** Runtime-facing facade for issuing builds. */
+export interface BuildExecutor {
+    build(options: BuildOptions): Promise<BuildResult>;
+}

package/src/build/contracts/build-manifest.d.ts

@@ -0,0 +1,90 @@
+import type { EcoBuildPlugin } from './build-types.js';
+import { type BrowserRuntimeManifest } from '../browser/browser-runtime-manifest.js';
+/**
+ * Sealed, app-owned registry of build plugins and browser runtime assets.
+ *
+ * @remarks
+ * Core assembles one manifest during {@link ConfigBuilder.build} and stores it on
+ * `appConfig.runtime.buildManifest`. Request policy reads from this manifest when
+ * constructing server and browser {@link BuildOptions}; profiles do not inject
+ * plugins themselves.
+ *
+ * Contributor naming differs by layer but maps to the same buckets:
+ *
+ * | Integration getter | Processor getter | Manifest bucket |
+ * | --- | --- | --- |
+ * | `plugins` | `plugins` | `runtimePlugins` |
+ * | `browserBuildPlugins` | `buildPlugins` | `browserBundlePlugins` |
+ * | `browserRuntimeManifest` | — | `browserRuntimeManifest` |
+ * | — (file loaders on config) | — | `loaderPlugins` |
+ *
+ * Use {@link getServerBuildPlugins} and {@link getBrowserBuildPlugins} to turn
+ * buckets into the plugin lists passed to Rolldown. App-aware call sites should
+ * prefer {@link getAppServerBuildPlugins} and {@link getAppBrowserBuildPlugins},
+ * which add alias resolution, JSX ownership, and browser source-transform
+ * deduplication on top of the manifest lists.
+ */
+export interface AppBuildManifest {
+    /** File-extension loaders registered on the app config (for example `.mdx`). */
+    loaderPlugins: EcoBuildPlugin[];
+    /**
+     * Shared plugins for server-oriented and browser-oriented builds.
+     *
+     * @remarks
+     * Sourced from integration `plugins` and processor `plugins`. Virtual-module
+     * loaders and transforms that must run during route-module transpile belong
+     * here.
+     */
+    runtimePlugins: EcoBuildPlugin[];
+    /**
+     * Browser-bundle-only plugins.
+     *
+     * @remarks
+     * Sourced from integration `browserBuildPlugins` and processor `buildPlugins`.
+     * Do not register server route or static-page transforms here.
+     */
+    browserBundlePlugins: EcoBuildPlugin[];
+    /**
+     * Specifier → public URL map for client bundles.
+     *
+     * @remarks
+     * Not a plugin list. {@link getBrowserBuildPlugins} synthesizes
+     * `browser-runtime-plugin` from this map to rewrite manifest-owned imports.
+     */
+    browserRuntimeManifest: BrowserRuntimeManifest;
+}
+/**
+ * Merges plugin lists while preserving first-registration precedence by name.
+ *
+ * @remarks
+ * Build manifests treat plugin names as stable identities. The first plugin
+ * with a given name wins so config-time assembly stays deterministic across
+ * loader, runtime, and browser buckets.
+ */
+export declare function mergeEcoBuildPlugins(...pluginLists: Array<EcoBuildPlugin[] | undefined>): EcoBuildPlugin[];
+/**
+ * Creates one app-owned build manifest from the supplied plugin buckets.
+ */
+export declare function createAppBuildManifest(input?: Partial<AppBuildManifest>): AppBuildManifest;
+/**
+ * Returns the shared browser runtime asset manifest sealed into the app build manifest.
+ */
+export declare function getBrowserRuntimeManifest(manifest: AppBuildManifest): BrowserRuntimeManifest;
+/**
+ * Returns the plugin list used for server-oriented builds.
+ *
+ * @remarks
+ * Merges `loaderPlugins` then `runtimePlugins`. Browser-only buckets and the
+ * synthesized browser-runtime rewrite plugin are excluded.
+ */
+export declare function getServerBuildPlugins(manifest: AppBuildManifest): EcoBuildPlugin[];
+/**
+ * Returns the plugin list used for browser-oriented builds.
+ *
+ * @remarks
+ * Merges, in order: `loaderPlugins`, `runtimePlugins`, a synthesized
+ * `browser-runtime-plugin` when `browserRuntimeManifest` has entries, then
+ * `browserBundlePlugins`. Plugin names dedupe with first-registration wins via
+ * {@link mergeEcoBuildPlugins}.
+ */
+export declare function getBrowserBuildPlugins(manifest: AppBuildManifest): EcoBuildPlugin[];

package/src/build/{build-manifest.js → contracts/build-manifest.js}

@@ -1,8 +1,8 @@
-import { createBrowserRuntimePlugin, DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME } from "./browser-runtime-plugin.js";
+import { createBrowserRuntimePlugin, DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME } from "../browser/browser-runtime-plugin.js";
 import {
   createBrowserRuntimeManifest,
   mergeBrowserRuntimeManifests
-} from "./browser-runtime-manifest.js";
+} from "../browser/browser-runtime-manifest.js";
 function mergeEcoBuildPlugins(...pluginLists) {
   const byName = /* @__PURE__ */ new Map();
   for (const plugins of pluginLists) {

package/src/build/{rolldown-adapter-helpers.d.ts → rolldown/rolldown-adapter-helpers.d.ts}

@@ -2,19 +2,33 @@
  * Shared helpers for the Rolldown-backed build adapters.
  *
  * @remarks
- * The standard {@link RolldownBuildAdapter} (one-shot production builds)
- * and the dev {@link RolldownDevBuildAdapter} (DevEngine-backed
- * incremental rebuilds) both need the same BuildOptions → Rolldown
- * mapping, the same dependency-graph extraction, and the same
- * post-build rewriting pipeline. This module hosts the shared code so
- * the two adapters stay semantically identical.
+ * The standard {@link RolldownBuildAdapter} uses these helpers for
+ * BuildOptions → Rolldown mapping, dependency-graph extraction, and the
+ * post-build rewriting pipeline.
  *
  * @module
  */
-import type { InputOptions, OutputOptions } from 'rolldown';
-import type { EcoBuildPlugin } from './build-types.js';
-import type { BuildDependencyGraph, BuildLog, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from './build-adapter.js';
+import type { InputOptions, OutputOptions, RolldownPlugin } from 'rolldown';
+import type { EcoBuildPlugin } from '../contracts/build-types.js';
+import type { BuildDependencyGraph, BuildLog, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from '../build-adapter.js';
 export declare function transpileProfileToOptions(profile: BuildTranspileProfile): BuildTranspileOptions;
+/**
+ * Resolves Node builtins as external before Rolldown falls back to file resolution.
+ *
+ * @remarks
+ * Rolldown documents two first-class externalization points: its `external`
+ * option is checked before resolution, and a plugin `resolveId` hook can return
+ * `{ id, external: true }`. Core uses the latter to keep Node-builtin ownership
+ * explicit in the Node-target plugin pipeline.
+ *
+ * The hook runs before Rolldown's internal filesystem resolver, leaving imports
+ * such as `node:fs` intact for the Node runtime. It is installed only for
+ * Node-target builds, so browser bundles still surface accidental Node builtin
+ * imports as resolver failures.
+ *
+ * See {@link https://rolldown.rs/in-depth/external-modules | Rolldown external modules}.
+ */
+export declare function createNodeBuiltinExternalPlugin(): RolldownPlugin;
 export declare function extractDependencyGraph(chunks: Array<{
     facadeModuleId: string | null;
     moduleIds: string[];

package/src/build/{rolldown-adapter-helpers.js → rolldown/rolldown-adapter-helpers.js}

@@ -1,10 +1,46 @@
-import { createRequire } from "node:module";
+import { builtinModules, createRequire } from "node:module";
+import { readFileSync } from "node:fs";
 import path from "node:path";
-import { collectBrowserRuntimeImportRewriteMap, rewriteBrowserRuntimeImports } from "./browser-runtime-plugin.js";
+import { isBarePackageImportSpecifier } from "../../plugins/tsconfig-import-resolver.js";
+import {
+  collectBrowserRuntimeImportRewriteMap,
+  rewriteBrowserRuntimeImports
+} from "../browser/browser-runtime-plugin.js";
 import { createServerSideCssShimPlugin } from "./server-side-css-shim-plugin.js";
 import { createRolldownPluginBridge } from "./rolldown-plugin-bridge.js";
-import { isDeclaredAppPackageImport, normalizeNodeRuntimeBuildOutputs } from "./runtime-build-output-normalizer.js";
-const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
+import {
+  isDeclaredAppPackageImport,
+  isWorkspacePackageImport,
+  normalizeNodeRuntimeBuildOutputs
+} from "./runtime-build-output-normalizer.js";
+const corePackageRequire = createRequire(new URL("../../../package.json", import.meta.url));
+const nodeBuiltinSpecifiers = new Set(builtinModules);
+let corePackageNames;
+function getCorePackageNames() {
+  if (corePackageNames) {
+    return corePackageNames;
+  }
+  const packageJsonPath = new URL("../../../package.json", import.meta.url);
+  corePackageNames = /* @__PURE__ */ new Set();
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const entries = packageJson[field];
+      if (!entries || typeof entries !== "object") {
+        continue;
+      }
+      for (const name of Object.keys(entries)) {
+        corePackageNames.add(name);
+      }
+    }
+  } catch {
+  }
+  return corePackageNames;
+}
+function isCoreDeclaredPackageImport(specifier) {
+  const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0] ?? specifier;
+  return getCorePackageNames().has(name);
+}
 function transpileProfileToOptions(profile) {
   switch (profile) {
     case "browser-script":
@@ -17,8 +53,8 @@ function transpileProfileToOptions(profile) {
       };
   }
 }
-function isPackageImport(id) {
-  return !id.startsWith(".") && !path.isAbsolute(id) && !id.startsWith("/") && !id.startsWith("node:") && !id.startsWith("@/") && !id.startsWith("~/") && !id.startsWith("#") && !id.includes(":");
+function isPackageImport(id, contextRoot) {
+  return isBarePackageImportSpecifier(id, contextRoot);
 }
 function tryResolveModule(id, resolver) {
   try {
@@ -37,13 +73,21 @@ function getAppRootRequire(cache, contextRoot) {
   return req;
 }
 function shouldBundlePackageImport(id, contextRoot, appRootRequireCache) {
+  if (isWorkspacePackageImport(id, contextRoot)) {
+    return true;
+  }
   if (isDeclaredAppPackageImport(id, contextRoot)) {
     const appRootRequire = getAppRootRequire(appRootRequireCache, contextRoot);
     const appResolvedPath = tryResolveModule(id, appRootRequire);
     return Boolean(appResolvedPath && /\.(?:[cm]?ts|tsx|jsx)$/u.test(appResolvedPath));
   }
-  const coreResolvedPath = tryResolveModule(id, corePackageRequire);
-  return Boolean(coreResolvedPath && /\.(?:[cm]?ts|tsx|jsx)$/u.test(coreResolvedPath));
+  if (isCoreDeclaredPackageImport(id)) {
+    const coreResolvedPath = tryResolveModule(id, corePackageRequire);
+    if (coreResolvedPath && !/\.(?:[cm]?ts|tsx|jsx)$/u.test(coreResolvedPath)) {
+      return false;
+    }
+  }
+  return true;
 }
 function createExternalMatcher(options, appRootRequireCache) {
   const explicitExternals = new Set(options.external ?? []);
@@ -53,12 +97,23 @@ function createExternalMatcher(options, appRootRequireCache) {
     if (explicitExternals.has(id)) {
       return true;
     }
-    if (!externalPackages || !isPackageImport(id)) {
+    if (!externalPackages || !isPackageImport(id, contextRoot)) {
       return false;
     }
     return !shouldBundlePackageImport(id, contextRoot, appRootRequireCache);
   };
 }
+function isNodeBuiltinSpecifier(id) {
+  return id.startsWith("node:") || nodeBuiltinSpecifiers.has(id);
+}
+function createNodeBuiltinExternalPlugin() {
+  return {
+    name: "ecopages-node-builtin-external",
+    resolveId(id) {
+      return isNodeBuiltinSpecifier(id) ? { id, external: true } : null;
+    }
+  };
+}
 function mapRolldownFormat(value) {
   switch (value) {
     case "cjs":
@@ -162,8 +217,13 @@ function resolveRolldownOptions(options, contextRoot, outdir, appRootRequireCach
     transformOptions.target = options.target;
   }
   const bundlePlugins = options.plugins ?? [];
-  const appPlugins = createRolldownPluginBridge(bundlePlugins, contextRoot);
-  const allPlugins = [...options.target !== "browser" ? [createServerSideCssShimPlugin()] : [], ...appPlugins];
+  const sourceTransforms = options.target === "browser" ? options.sourceTransforms ?? [] : [];
+  const appPlugins = createRolldownPluginBridge(bundlePlugins, contextRoot, sourceTransforms);
+  const allPlugins = [
+    ...mapRolldownPlatform(options.target) === "node" ? [createNodeBuiltinExternalPlugin()] : [],
+    ...options.target !== "browser" ? [createServerSideCssShimPlugin()] : [],
+    ...appPlugins
+  ];
   const inputOptions = {
     input: options.entrypoints,
     cwd: contextRoot,
@@ -172,6 +232,11 @@ function resolveRolldownOptions(options, contextRoot, outdir, appRootRequireCach
     transform: Object.keys(transformOptions).length > 0 ? transformOptions : void 0,
     resolve: options.conditions ? { conditionNames: options.conditions } : void 0,
     treeshake: typeof options.treeshaking === "boolean" ? options.treeshaking : true,
+    ...process.env.ECOPAGES_PROFILE_BUILD === "1" ? {} : {
+      checks: {
+        pluginTimings: false
+      }
+    },
     experimental: {
       nativeMagicString: true
     },
@@ -215,11 +280,21 @@ function rewriteBrowserRuntimeImportsInOutputs(result, contextRoot, plugins) {
     if (rewritten !== code) {
       fs.writeFileSync(output.path, rewritten);
     }
-    rewriteCache.add(contentKey);
+    rememberRewrite(contentKey);
   }
   return result;
 }
+const REWRITE_CACHE_MAX_ENTRIES = 2048;
 const rewriteCache = /* @__PURE__ */ new Set();
+function rememberRewrite(contentKey) {
+  rewriteCache.add(contentKey);
+  if (rewriteCache.size > REWRITE_CACHE_MAX_ENTRIES) {
+    const oldest = rewriteCache.values().next().value;
+    if (oldest !== void 0) {
+      rewriteCache.delete(oldest);
+    }
+  }
+}
 function djb2(input) {
   let hash = 5381;
   for (let i = 0; i < input.length; i++) {
@@ -246,16 +321,27 @@ function buildResultFromRolldownOutput(output, outdir, contextRoot) {
   }));
   const entryChunks = output.output.filter((entry) => entry.type === "chunk" && entry.isEntry);
   const dependencyGraph = entryChunks.length > 0 ? extractDependencyGraph(entryChunks, contextRoot) : void 0;
+  const entryOutputs = {};
+  for (const chunk of entryChunks) {
+    if (chunk.facadeModuleId) {
+      entryOutputs[normalizeModulePath(chunk.facadeModuleId, contextRoot)] = normalizeOutputPath(
+        chunk.fileName,
+        outdir
+      );
+    }
+  }
   return {
     success: true,
     logs: [],
     outputs,
-    dependencyGraph
+    dependencyGraph,
+    entryOutputs: entryChunks.length > 0 ? entryOutputs : void 0
   };
 }
 export {
   buildResultFromRolldownOutput,
   clearRewriteCacheForTests,
+  createNodeBuiltinExternalPlugin,
   extractDependencyGraph,
   resolveRolldownOptions,
   rewriteBrowserRuntimeImportsInOutputs,

package/src/build/{rolldown-build-adapter.d.ts → rolldown/rolldown-build-adapter.d.ts}

@@ -6,19 +6,15 @@
  * default adapter installed by `ConfigBuilder` and the adapter that
  * issues real builds in production.
  *
- * Each `build()` creates a fresh `rolldown()` bundler, so there is no
- * module-graph reuse across calls. For HMR/watch mode where the same
- * entrypoints are rebuilt repeatedly, see {@link RolldownDevBuildAdapter}.
+ * Each `build()` creates a fresh `rolldown()` bundler.
  */
-import type { BuildAdapter, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from './build-adapter.js';
+import type { BuildAdapter, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from '../build-adapter.js';
 export declare class RolldownBuildAdapter implements BuildAdapter {
     readonly ownership: "rolldown";
     /** Per-adapter require cache, keyed on resolved context root. */
     private readonly appRootRequireCache;
     /**
-     * Issues one build. Creates a fresh `rolldown()` bundler per call,
-     * so no module-graph reuse. For repeated rebuilds on the same
-     * entrypoints, use {@link RolldownDevBuildAdapter}.
+     * Issues one build. Creates a fresh `rolldown()` bundler per call.
      */
     buildOrThrow(options: BuildOptions): Promise<BuildResult>;
     build(options: BuildOptions): Promise<BuildResult>;

package/src/build/{rolldown-build-adapter.js → rolldown/rolldown-build-adapter.js}

@@ -9,17 +9,17 @@ import {
   toBuildLogs,
   transpileProfileToOptions
 } from "./rolldown-adapter-helpers.js";
+import { recordRolldownBuildInvocation } from "./rolldown-build-invocation-metrics.js";
 const moduleRequire = createRequire(import.meta.url);
 class RolldownBuildAdapter {
   ownership = "rolldown";
   /** Per-adapter require cache, keyed on resolved context root. */
   appRootRequireCache = /* @__PURE__ */ new Map();
   /**
-   * Issues one build. Creates a fresh `rolldown()` bundler per call,
-   * so no module-graph reuse. For repeated rebuilds on the same
-   * entrypoints, use {@link RolldownDevBuildAdapter}.
+   * Issues one build. Creates a fresh `rolldown()` bundler per call.
    */
   async buildOrThrow(options) {
+    recordRolldownBuildInvocation("rolldown");
     const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
     const outdir = path.resolve(options.outdir ?? "dist/assets");
     const plugins = options.plugins ?? [];

package/src/build/rolldown/rolldown-build-invocation-metrics.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Process-wide Rolldown build invocation counters for benchmarks and spikes.
+ *
+ * Gated behind {@link isRolldownBuildMetricsEnabled} so production paths stay quiet.
+ */
+export declare function isRolldownBuildMetricsEnabled(): boolean;
+export declare function recordRolldownBuildInvocation(adapter?: 'rolldown'): void;
+export declare function getRolldownBuildInvocationCounts(): Readonly<Record<string, number>>;
+export declare function resetRolldownBuildInvocationCounts(): void;
+export declare function recordPageModuleBuildInvocation(): void;
+export declare function getPageModuleRolldownBuildInvocations(): number;
+export declare function getTotalRolldownBuildInvocations(): number;