@ecopages/core 0.2.0-beta.2 → 0.2.0-beta.20

package/src/build/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/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 "../services/module-loading/route-module-build-manifest.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/rolldown-adapter-helpers.d.ts

@@ -2,12 +2,9 @@
  * 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
  */

package/src/build/rolldown-adapter-helpers.js

@@ -1,10 +1,41 @@
 import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import { collectBrowserRuntimeImportRewriteMap, rewriteBrowserRuntimeImports } from "./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";
+import {
+  isDeclaredAppPackageImport,
+  isWorkspacePackageImport,
+  normalizeNodeRuntimeBuildOutputs
+} from "./runtime-build-output-normalizer.js";
 const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
+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":
@@ -37,13 +68,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 ?? []);
@@ -162,7 +201,8 @@ function resolveRolldownOptions(options, contextRoot, outdir, appRootRequireCach
     transformOptions.target = options.target;
   }
   const bundlePlugins = options.plugins ?? [];
-  const appPlugins = createRolldownPluginBridge(bundlePlugins, contextRoot);
+  const sourceTransforms = options.target === "browser" ? options.sourceTransforms ?? [] : [];
+  const appPlugins = createRolldownPluginBridge(bundlePlugins, contextRoot, sourceTransforms);
   const allPlugins = [...options.target !== "browser" ? [createServerSideCssShimPlugin()] : [], ...appPlugins];
   const inputOptions = {
     input: options.entrypoints,
@@ -172,6 +212,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 +260,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,11 +301,21 @@ 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 {

package/src/build/rolldown-build-adapter.d.ts

@@ -6,9 +6,7 @@
  * 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';
 export declare class RolldownBuildAdapter implements BuildAdapter {
@@ -16,9 +14,7 @@ export declare class RolldownBuildAdapter implements BuildAdapter {
     /** 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

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

package/src/build/rolldown-build-invocation-metrics.js

@@ -0,0 +1,43 @@
+const invocationCounts = /* @__PURE__ */ new Map();
+let pageModuleBuildInvocations = 0;
+function isRolldownBuildMetricsEnabled() {
+  return process.env.ECOPAGES_ROLLDOWN_BUILD_METRICS === "1" || process.env.ECOPAGES_LOGGER_DEBUG === "true";
+}
+function recordRolldownBuildInvocation(adapter = "rolldown") {
+  if (!isRolldownBuildMetricsEnabled()) {
+    return;
+  }
+  invocationCounts.set(adapter, (invocationCounts.get(adapter) ?? 0) + 1);
+}
+function getRolldownBuildInvocationCounts() {
+  return Object.fromEntries(invocationCounts);
+}
+function resetRolldownBuildInvocationCounts() {
+  invocationCounts.clear();
+  pageModuleBuildInvocations = 0;
+}
+function recordPageModuleBuildInvocation() {
+  if (!isRolldownBuildMetricsEnabled()) {
+    return;
+  }
+  pageModuleBuildInvocations += 1;
+}
+function getPageModuleRolldownBuildInvocations() {
+  return pageModuleBuildInvocations;
+}
+function getTotalRolldownBuildInvocations() {
+  let total = 0;
+  for (const count of invocationCounts.values()) {
+    total += count;
+  }
+  return total;
+}
+export {
+  getPageModuleRolldownBuildInvocations,
+  getRolldownBuildInvocationCounts,
+  getTotalRolldownBuildInvocations,
+  isRolldownBuildMetricsEnabled,
+  recordPageModuleBuildInvocation,
+  recordRolldownBuildInvocation,
+  resetRolldownBuildInvocationCounts
+};

package/src/build/rolldown-plugin-bridge.d.ts

@@ -40,6 +40,7 @@
  * on every source file.
  */
 import type { Plugin } from 'rolldown';
+import type { EcoSourceTransform } from '../plugins/source-transform.js';
 import type { EcoBuildPlugin } from './build-types.js';
 /**
  * Creates a Rolldown `Plugin` array that drives the supplied
@@ -55,5 +56,18 @@ import type { EcoBuildPlugin } from './build-types.js';
  * Plugin ordering is preserved: registrations from earlier eco plugins
  * are checked before registrations from later ones, matching the
  * original per-plugin priority semantics.
+ *
+ * @remarks
+ * Rolldown re-fires `buildStart` on each build, so registrations and the
+ * virtual-module counter are cleared before every `setup` pass — otherwise
+ * handlers accumulate when bridge plugins are reused.
+ *
+ * @param plugins - `EcoBuildPlugin` instances registered for this build.
+ * @param contextRoot - Project root used to resolve relative load paths.
+ * @param sourceTransforms - Optional app-owned transforms applied after a matching
+ * `onLoad` handler returns module contents. Browser builds pass
+ * {@link getAppSourceTransforms | app source transforms} here so metadata injection
+ * still runs on output rewritten by boundary/runtime plugins. Virtual modules,
+ * CSS, and asset loads are skipped.
  */
-export declare function createRolldownPluginBridge(plugins: EcoBuildPlugin[], contextRoot: string): Plugin[];
+export declare function createRolldownPluginBridge(plugins: EcoBuildPlugin[], contextRoot: string, sourceTransforms?: readonly EcoSourceTransform[]): Plugin[];

package/src/build/rolldown-plugin-bridge.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { finalizeLoadResultWithSourceTransforms } from "./rolldown-source-transform-pass.js";
 import { escapeRegExp } from "./browser-runtime-plugin-helpers.js";
 const NAMESPACE_SEPARATOR = ":";
 function joinNamespace(namespace, value) {
@@ -124,7 +125,7 @@ function convertPluginOnResolveResult(result, importer, contextRoot) {
   }
   return partial;
 }
-function createRolldownPluginBridge(plugins, contextRoot) {
+function createRolldownPluginBridge(plugins, contextRoot, sourceTransforms = []) {
   if (plugins.length === 0) {
     return [];
   }
@@ -152,22 +153,36 @@ function createRolldownPluginBridge(plugins, contextRoot) {
     return void 0;
   };
   const loadHandler = async (id) => {
+    let loadResult;
     for (const { filter, callback } of loadRegistrations) {
       if (!filter.test(id)) {
         continue;
       }
-      const { namespace, path: sourcePath } = splitNamespace(id);
-      const result = await callback({ path: sourcePath, namespace });
+      const { namespace: namespace2, path: sourcePath2 } = splitNamespace(id);
+      const result = await callback({ path: sourcePath2, namespace: namespace2 });
       const converted = convertPluginOnLoadResult({ id }, result);
       if (converted !== void 0) {
-        return converted;
+        loadResult = converted;
+        break;
       }
     }
-    return void 0;
+    const { namespace, path: sourcePath } = splitNamespace(id);
+    return finalizeLoadResultWithSourceTransforms({
+      id,
+      namespace,
+      sourcePath,
+      loadResult,
+      sourceTransforms,
+      contextRoot,
+      inferModuleTypeFromPath: (filePath) => inferRolldownModuleTypeFromPath(filePath)
+    });
   };
   const plugin = {
     name: "ecopages-plugin-bridge",
     buildStart: async () => {
+      resolveRegistrations.length = 0;
+      loadRegistrations.length = 0;
+      moduleCounter.value = 0;
       for (const ecoPlugin of plugins) {
         const bridge = {
           onResolve: (options, callback) => {

package/src/build/rolldown-source-transform-pass.d.ts

@@ -0,0 +1,15 @@
+import type { LoadResult, SourceDescription } from 'rolldown';
+import { type EcoSourceTransform } from '../plugins/source-transform.js';
+/**
+ * Runs app-owned source transforms after first-wins `onLoad` plugins produce
+ * module contents for one Rolldown load request.
+ */
+export declare function finalizeLoadResultWithSourceTransforms(options: {
+    id: string;
+    namespace: string | undefined;
+    sourcePath: string;
+    loadResult: LoadResult | undefined;
+    sourceTransforms: readonly EcoSourceTransform[];
+    contextRoot: string;
+    inferModuleTypeFromPath: (filePath: string) => SourceDescription['moduleType'];
+}): Promise<LoadResult | undefined>;

package/src/build/rolldown-source-transform-pass.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { applySourceTransforms, normalizeTransformId } from "../plugins/source-transform.js";
+const TRANSFORMABLE_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mdx"]);
+function shouldApplySourceTransforms(namespace, sourcePath) {
+  if (namespace !== void 0) {
+    return false;
+  }
+  const normalizedPath = normalizeTransformId(sourcePath);
+  return TRANSFORMABLE_SOURCE_EXTENSIONS.has(path.extname(normalizedPath).toLowerCase());
+}
+function shouldTransformLoadedModule(moduleType) {
+  return moduleType !== "css" && moduleType !== "asset";
+}
+function applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, code) {
+  if (sourceTransforms.length === 0) {
+    return code;
+  }
+  return applySourceTransforms(sourceTransforms, code, sourcePath);
+}
+async function finalizeLoadResultWithSourceTransforms(options) {
+  const { id, namespace, sourcePath, loadResult, sourceTransforms, contextRoot, inferModuleTypeFromPath } = options;
+  if (!shouldApplySourceTransforms(namespace, sourcePath)) {
+    return loadResult;
+  }
+  if (typeof loadResult === "object" && loadResult !== null && "code" in loadResult && typeof loadResult.code === "string") {
+    if (!shouldTransformLoadedModule(loadResult.moduleType)) {
+      return loadResult;
+    }
+    const transformedCode2 = applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, loadResult.code);
+    if (transformedCode2 === loadResult.code) {
+      return loadResult;
+    }
+    return {
+      code: transformedCode2,
+      moduleType: loadResult.moduleType
+    };
+  }
+  if (loadResult !== void 0 || sourceTransforms.length === 0) {
+    return loadResult;
+  }
+  const normalizedPath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(contextRoot, sourcePath);
+  if (!fileSystem.exists(normalizedPath)) {
+    return loadResult;
+  }
+  const originalCode = fileSystem.readFileSync(normalizedPath);
+  const transformedCode = applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, originalCode);
+  if (transformedCode === originalCode) {
+    return loadResult;
+  }
+  return {
+    code: transformedCode,
+    moduleType: inferModuleTypeFromPath(normalizedPath)
+  };
+}
+export {
+  finalizeLoadResultWithSourceTransforms
+};

package/src/build/runtime-build-executor.d.ts

@@ -1,21 +1,14 @@
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import { type BuildExecutor } from './build-adapter.js';
+import type { BuildExecutor } from './build-adapter.js';
+export type { BuildProfile, BuildRuntime } from './build-runtime.js';
+export { disposeAppBuildRuntime, getBuildRuntime, installBuildRuntime, requireBuildRuntime } from './build-runtime.js';
 /**
- * Installs the app-owned runtime build executor for one app instance.
+ * Installs the app-owned runtime build executors for one app instance.
  *
  * @remarks
- * Wraps the app-owned adapter in a {@link SerializedBuildExecutor} so
- * every dev-watch caller issues builds against a single FIFO queue.
- * Plugin injection is applied here via {@link withBuildExecutorPlugins}
- * so app-owned plugins are merged into every rebuild without callers
- * having to know about the manifest.
- *
- * Idempotent across calls: re-invoking replaces the existing executor
- * on `appConfig.runtime` with a fresh wrapper.
- *
- * @param appConfig - The app config whose runtime state is updated.
- *   The function reads the existing executor (falling back to the
- *   app-owned adapter) and writes the wrapped executor back.
- * @returns The installed {@link BuildExecutor}.
+ * Delegates to {@link installBuildRuntime}. Route-module and HMR browser builds
+ * use parallel one-shot Rolldown. Server-entry bundling stays serialized
+ * single-flight.
  */
 export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;
+export declare function getInstalledServerEntryBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;

package/src/build/runtime-build-executor.js

@@ -1,19 +1,16 @@
-import {
-  getAppBuildAdapter,
-  getAppBuildExecutor,
-  getAppServerBuildPlugins,
-  setAppBuildExecutor,
-  withBuildExecutorPlugins
-} from "./build-adapter.js";
-import { SerializedBuildExecutor } from "./serialized-build-executor.js";
+import { installBuildRuntime, requireBuildRuntime } from "./build-runtime.js";
+import { disposeAppBuildRuntime, getBuildRuntime, installBuildRuntime as installBuildRuntime2, requireBuildRuntime as requireBuildRuntime2 } from "./build-runtime.js";
 function installAppRuntimeBuildExecutor(appConfig) {
-  const baseExecutor = getAppBuildExecutor(appConfig) ?? getAppBuildAdapter(appConfig);
-  const buildExecutor = new SerializedBuildExecutor(
-    withBuildExecutorPlugins(baseExecutor, () => getAppServerBuildPlugins(appConfig))
-  );
-  setAppBuildExecutor(appConfig, buildExecutor);
-  return buildExecutor;
+  return installBuildRuntime(appConfig).getProfile("route-module");
+}
+function getInstalledServerEntryBuildExecutor(appConfig) {
+  return requireBuildRuntime(appConfig).getProfile("server-entry");
 }
 export {
-  installAppRuntimeBuildExecutor
+  disposeAppBuildRuntime,
+  getBuildRuntime,
+  getInstalledServerEntryBuildExecutor,
+  installAppRuntimeBuildExecutor,
+  installBuildRuntime2 as installBuildRuntime,
+  requireBuildRuntime2 as requireBuildRuntime
 };

package/src/build/runtime-build-output-normalizer.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Returns true if the given specifier is a workspace package.
+ *
+ * Workspace packages are declared with the `workspace:` protocol and are
+ * typically source-only, requiring bundling rather than externalization.
+ */
+export declare function isWorkspacePackageImport(specifier: string, rootDir: string): boolean;
 export declare function isDeclaredAppPackageImport(specifier: string, rootDir: string): boolean;
 export declare function normalizeNodeRuntimeBuildOutputFile(filePath: string, rootDir: string): void;
 export declare function normalizeNodeRuntimeBuildOutputs(outputPaths: string[], rootDir: string): void;