@ecopages/core 0.2.0-beta.7 → 0.2.0-beta.9

package/src/build/build-adapter.js

@@ -1,13 +1,15 @@
 import { mergeBrowserRuntimeManifests } from "./browser-runtime-manifest.js";
 import { normalizeNodeRuntimeBuildOutputs } from "./runtime-build-output-normalizer.js";
-import { createForeignJsxOverridePlugin } from "../plugins/foreign-jsx-override-plugin.js";
 import {
   createAppBuildManifest,
   getBrowserBuildPlugins,
   getServerBuildPlugins
 } from "./build-manifest.js";
+import { getAppSourceTransforms } from "../plugins/source-transform.js";
+import { getJsxOwnershipPlugins } from "./jsx-ownership-plugins.js";
 import { createRolldownBuildAdapter } from "./rolldown-build-adapter.js";
 import { createRolldownDevBuildAdapter } from "./rolldown-dev-build-adapter.js";
+import { appLogger } from "../global/app-logger.js";
 function mergeBuildExecutorPlugins(existing, appPlugins) {
   if (!existing || existing.length === 0) {
     return appPlugins;
@@ -96,7 +98,7 @@ function setAppBuildAdapter(appConfig, buildAdapter) {
 }
 function getAppBuildManifest(appConfig) {
   return appConfig.runtime?.buildManifest ?? createAppBuildManifest({
-    loaderPlugins: Array.from(appConfig.loaders.values())
+    loaderPlugins: Array.from(appConfig.loaders?.values() ?? [])
   });
 }
 function setAppBuildManifest(appConfig, buildManifest) {
@@ -143,27 +145,55 @@ async function collectConfiguredAppBuildManifestContributions(appConfig) {
   };
 }
 async function setupAppRuntimePlugins(options) {
-  for (const loader of options.appConfig.loaders.values()) {
-    options.onRuntimePlugin?.(loader);
-  }
-  for (const processor of options.appConfig.processors.values()) {
-    await processor.setup();
-    if (processor.plugins) {
-      for (const plugin of processor.plugins) {
+  if (options.appConfig.runtime?.runtimeAssetsPrepared) {
+    appLogger.debug("Skipped setupAppRuntimePlugins: runtime assets already prepared");
+    for (const loader of options.appConfig.loaders.values()) {
+      options.onRuntimePlugin?.(loader);
+    }
+    for (const processor of options.appConfig.processors.values()) {
+      if (processor.plugins) {
+        for (const plugin of processor.plugins) {
+          options.onRuntimePlugin?.(plugin);
+        }
+      }
+    }
+    for (const integration of options.appConfig.integrations) {
+      for (const plugin of integration.plugins) {
         options.onRuntimePlugin?.(plugin);
       }
     }
+    return;
   }
-  for (const integration of options.appConfig.integrations) {
-    integration.setConfig(options.appConfig);
-    integration.setRuntimeOrigin(options.runtimeOrigin);
-    if (options.hmrManager) {
-      integration.setHmrManager(options.hmrManager);
+  appLogger.debugTime("setupAppRuntimePlugins");
+  try {
+    for (const loader of options.appConfig.loaders.values()) {
+      options.onRuntimePlugin?.(loader);
     }
-    await integration.setup();
-    for (const plugin of integration.plugins) {
-      options.onRuntimePlugin?.(plugin);
+    for (const processor of options.appConfig.processors.values()) {
+      await processor.setup();
+      if (processor.plugins) {
+        for (const plugin of processor.plugins) {
+          options.onRuntimePlugin?.(plugin);
+        }
+      }
     }
+    for (const integration of options.appConfig.integrations) {
+      integration.setConfig(options.appConfig);
+      integration.setRuntimeOrigin(options.runtimeOrigin);
+      if (options.hmrManager) {
+        integration.setHmrManager(options.hmrManager);
+      }
+      await integration.setup();
+      for (const plugin of integration.plugins) {
+        options.onRuntimePlugin?.(plugin);
+      }
+    }
+    options.appConfig.runtime = {
+      ...options.appConfig.runtime ?? {},
+      runtimeAssetsPrepared: true
+    };
+  } finally {
+    appLogger.debugTimeEnd("setupAppRuntimePlugins");
   }
 }
 function getAppServerBuildPlugins(appConfig) {
@@ -171,24 +201,20 @@ function getAppServerBuildPlugins(appConfig) {
 }
 function getAppBrowserBuildPlugins(appConfig) {
   const manifest = getAppBuildManifest(appConfig);
-  const jsxOwnershipPlugins = collectJsxOwnershipPlugins(appConfig);
-  return [...getBrowserBuildPlugins(manifest), ...jsxOwnershipPlugins];
-}
-function collectJsxOwnershipPlugins(appConfig) {
-  const jsxExtensions = (appConfig.integrations ?? []).filter((integration) => integration.jsxImportSource).flatMap(
-    (integration) => integration.extensions.filter((extension) => extension.endsWith(".tsx") || extension.endsWith(".jsx")).map((extension) => ({ integration, extension }))
-  ).sort((left, right) => right.extension.length - left.extension.length);
-  return jsxExtensions.map(
-    ({ integration, extension }) => createForeignJsxOverridePlugin({
-      hostJsxImportSource: integration.jsxImportSource,
-      foreignExtensions: [extension],
-      excludeExtensions: jsxExtensions.filter((candidate) => candidate.extension.length > extension.length).filter((candidate) => candidate.extension.endsWith(extension)).map((candidate) => candidate.extension),
-      name: `ecopages-jsx-ownership-${integration.name}-${extension.replace(/[^a-zA-Z0-9]+/g, "-")}`
-    })
+  const sourceTransformNames = new Set(getAppSourceTransforms(appConfig).map((transform) => transform.name));
+  const browserPlugins = getBrowserBuildPlugins(manifest).filter(
+    (plugin) => !sourceTransformNames.has(plugin.name)
   );
+  return [...browserPlugins, ...getJsxOwnershipPlugins(appConfig)];
 }
 function getAppBuildExecutor(appConfig) {
-  return appConfig.runtime?.buildExecutor ?? getAppBuildAdapter(appConfig);
+  return appConfig.runtime?.routeModuleBuildExecutor ?? appConfig.runtime?.buildExecutor ?? getAppBuildAdapter(appConfig);
+}
+function getAppHmrBuildExecutor(appConfig) {
+  return appConfig.runtime?.hmrBuildExecutor ?? getAppBuildExecutor(appConfig);
+}
+function getAppRouteModuleBuildExecutor(appConfig) {
+  return appConfig.runtime?.routeModuleBuildExecutor ?? getAppBuildExecutor(appConfig);
 }
 function setAppBuildExecutor(appConfig, buildExecutor) {
   appConfig.runtime = {
@@ -196,6 +222,19 @@ function setAppBuildExecutor(appConfig, buildExecutor) {
     buildExecutor
   };
 }
+function setAppHmrBuildExecutor(appConfig, buildExecutor) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    hmrBuildExecutor: buildExecutor
+  };
+}
+function setAppRouteModuleBuildExecutor(appConfig, buildExecutor) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    routeModuleBuildExecutor: buildExecutor,
+    buildExecutor
+  };
+}
 function build(options, executor = defaultRolldownBuildAdapter) {
   return executor.build(options).then((result) => {
     if (result.success) {
@@ -228,6 +267,8 @@ export {
   getAppBuildExecutor,
   getAppBuildManifest,
   getAppBuildOwnership,
+  getAppHmrBuildExecutor,
+  getAppRouteModuleBuildExecutor,
   getAppServerBuildPlugins,
   getAppTranspileOptions,
   getBuildAdapterOwnership,
@@ -237,6 +278,8 @@ export {
   setAppBuildExecutor,
   setAppBuildManifest,
   setAppBuildOwnership,
+  setAppHmrBuildExecutor,
+  setAppRouteModuleBuildExecutor,
   setupAppRuntimePlugins,
   updateAppBuildManifest,
   withBuildExecutorPlugins

package/src/build/build-input-fingerprint.d.ts

@@ -0,0 +1,28 @@
+import type { IntegrationPlugin } from '../plugins/integration-plugin.js';
+import type { Processor } from '../plugins/processor.js';
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+/**
+ * Optional contributor surface for build-time cache invalidation.
+ *
+ * @remarks
+ * Processors and integrations may override {@link didChange} to report that
+ * their build inputs changed independently of route source files.
+ */
+export interface BuildInputChangeContributor {
+    /**
+     * Returns `true` when this contributor's build inputs changed since the last
+     * persisted incremental build metadata was written.
+     */
+    didChange?(): boolean;
+}
+/** Returns whether a processor or integration signals changed build inputs. */
+export declare function didBuildInputContributorChange(contributor: BuildInputChangeContributor): boolean;
+/** Hashes the app's eco.config.ts file when present. */
+export declare function hashAppConfigFile(appConfig: EcoPagesAppConfig): string;
+/** Fingerprints processor/integration build-input state for cache invalidation. */
+export declare function createBuildInputsFingerprint(appConfig: EcoPagesAppConfig): string;
+/** Returns true when any processor or integration reports changed build inputs. */
+export declare function haveBuildInputsChanged(appConfig: EcoPagesAppConfig): boolean;
+/** Collects every processor and integration that can invalidate incremental builds. */
+export declare function collectBuildInputContributors(appConfig: EcoPagesAppConfig): BuildInputChangeContributor[];
+export type { Processor, IntegrationPlugin };

package/src/build/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/jsx-ownership-plugins.d.ts

@@ -0,0 +1,10 @@
+import type { EcoBuildPlugin } from './build-types.js';
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+/**
+ * Foreign JSX override plugins for mixed-integration apps (Kita + React, etc.).
+ *
+ * Each plugin rewrites files for one `(integration, extension)` pair with a
+ * `@jsxImportSource` pragma so the bundler compiles against the owning runtime.
+ * Extensions are sorted longest-first so `.page.react.tsx` wins over `.tsx`.
+ */
+export declare function getJsxOwnershipPlugins(appConfig: EcoPagesAppConfig): EcoBuildPlugin[];

package/src/build/jsx-ownership-plugins.js

@@ -0,0 +1,17 @@
+import { createForeignJsxOverridePlugin } from "../plugins/foreign-jsx-override-plugin.js";
+function getJsxOwnershipPlugins(appConfig) {
+  const jsxExtensions = (appConfig.integrations ?? []).filter((integration) => integration.jsxImportSource).flatMap(
+    (integration) => integration.extensions.filter((extension) => extension.endsWith(".tsx") || extension.endsWith(".jsx")).map((extension) => ({ integration, extension }))
+  ).sort((left, right) => right.extension.length - left.extension.length);
+  return jsxExtensions.map(
+    ({ integration, extension }) => createForeignJsxOverridePlugin({
+      hostJsxImportSource: integration.jsxImportSource,
+      foreignExtensions: [extension],
+      excludeExtensions: jsxExtensions.filter((candidate) => candidate.extension.length > extension.length).filter((candidate) => candidate.extension.endsWith(extension)).map((candidate) => candidate.extension),
+      name: `ecopages-jsx-ownership-${integration.name}-${extension.replace(/[^a-zA-Z0-9]+/g, "-")}`
+    })
+  );
+}
+export {
+  getJsxOwnershipPlugins
+};

package/src/build/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/pages-unified-graph-build.js

@@ -0,0 +1,208 @@
+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, getAppRouteModuleBuildExecutor, getAppServerBuildPlugins } from "./build-adapter.js";
+import { createBuildInputsFingerprint, hashAppConfigFile } from "./build-input-fingerprint.js";
+import { getCorePackageVersion } from "../services/module-loading/route-module-build-manifest.js";
+import { resolveInternalExecutionDir } from "../utils/resolve-work-dir.js";
+import { getSharedRouteModuleBuildCache } from "../services/module-loading/route-module-build-cache-registry.js";
+import { normalizeNodeRuntimeBuildOutputFile } from "./runtime-build-output-normalizer.js";
+import { resolveRouteModuleDependencyPaths } from "../services/module-loading/route-module-dependency-hasher.js";
+import { getJsxOwnershipPlugins } from "./jsx-ownership-plugins.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 plugins = appConfig.runtime?.buildManifest ? getAppServerBuildPlugins(appConfig) : [];
+  const pluginNames = [...plugins, ...getJsxOwnershipPlugins(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 manifestPath = getPagesUnifiedGraphCachePath(appConfig);
+  if (!fileSystem.exists(manifestPath)) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(fileSystem.readFileSync(manifestPath));
+    if (!parsed?.outputs) {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function writePagesUnifiedGraphManifest(appConfig, manifest) {
+  const manifestPath = getPagesUnifiedGraphCachePath(appConfig);
+  fileSystem.ensureDir(path.dirname(manifestPath));
+  fileSystem.write(manifestPath, `${JSON.stringify(manifest, null, "	")}
+`);
+}
+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(entryKey, buildResult) {
+  const outputs = buildResult.outputs.map((output) => output.path);
+  for (const outputPath of 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 (manifest.invalidationVersion !== getCorePackageVersion()) {
+    return false;
+  }
+  if (manifest.buildInputsFingerprint !== createBuildInputsFingerprint(appConfig)) {
+    return false;
+  }
+  if (manifest.buildKey !== 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 plugins = options.appConfig.runtime?.buildManifest ? getAppServerBuildPlugins(options.appConfig) : [];
+  const mergedPlugins = [...plugins, ...getJsxOwnershipPlugins(options.appConfig)];
+  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 buildResult = await build(
+    {
+      entrypoints: entryRecord,
+      root: options.appConfig.rootDir,
+      outdir,
+      target: "es2022",
+      format: "esm",
+      sourcemap: "none",
+      splitting: true,
+      minify: false,
+      naming: "[name]-[hash].[ext]",
+      externalPackages: true,
+      plugins: mergedPlugins.length > 0 ? mergedPlugins : void 0
+    },
+    getAppRouteModuleBuildExecutor(options.appConfig)
+  );
+  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(entryKey, buildResult) : void 0;
+    if (!compiledOutput) {
+      throw new Error(`Pages unified graph build produced no output for ${entryPath}`);
+    }
+    normalizeNodeRuntimeBuildOutputFile(compiledOutput, options.appConfig.rootDir);
+    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: mergedPlugins
+    });
+  }
+  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/parallel-build-executor.d.ts

@@ -0,0 +1,21 @@
+import type { BuildExecutor, BuildOptions, BuildResult } from './build-adapter.js';
+/**
+ * Concurrency-limited build executor wrapper.
+ *
+ * @remarks
+ * Runs up to `limit` builds concurrently. Use for independent route-module
+ * and HMR browser builds where FIFO serialization is unnecessary.
+ */
+export declare class ParallelBuildExecutor implements BuildExecutor {
+    private readonly inner;
+    private readonly limit;
+    private activeCount;
+    private queue;
+    constructor(inner: BuildExecutor, limit: number);
+    build(options: BuildOptions): Promise<BuildResult>;
+    private drainQueue;
+    unwrap(): BuildExecutor;
+    getConcurrencyLimitForTests(): number;
+    getActiveCountForTests(): number;
+    getQueuedCountForTests(): number;
+}

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

@@ -0,0 +1,52 @@
+class ParallelBuildExecutor {
+  inner;
+  limit;
+  activeCount = 0;
+  queue = [];
+  constructor(inner, limit) {
+    this.inner = inner;
+    this.limit = Math.max(1, limit);
+  }
+  build(options) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        operation: () => this.inner.build(options),
+        resolve,
+        reject
+      });
+      this.drainQueue();
+    });
+  }
+  drainQueue() {
+    while (this.activeCount < this.limit && this.queue.length > 0) {
+      const next = this.queue.shift();
+      if (!next) {
+        return;
+      }
+      this.activeCount += 1;
+      void next.operation().then((result) => {
+        next.resolve(result);
+      }).catch((error) => {
+        next.reject(error);
+      }).finally(() => {
+        this.activeCount -= 1;
+        this.drainQueue();
+      });
+    }
+  }
+  unwrap() {
+    return this.inner;
+  }
+  getConcurrencyLimitForTests() {
+    return this.limit;
+  }
+  getActiveCountForTests() {
+    return this.activeCount;
+  }
+  getQueuedCountForTests() {
+    return this.queue.length;
+  }
+}
+export {
+  ParallelBuildExecutor
+};

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

@@ -201,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,
@@ -211,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
     },

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

@@ -9,6 +9,7 @@ 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";
@@ -20,6 +21,7 @@ class RolldownBuildAdapter {
    * entrypoints, use {@link RolldownDevBuildAdapter}.
    */
   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' | 'rolldown-dev'): 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
+};