@ecopages/core 0.2.0-alpha.8 → 0.2.1-beta.0

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

@@ -0,0 +1,28 @@
+/**
+ * Bundler-backed build adapter.
+ *
+ * @remarks
+ * Implements {@link BuildAdapter} on top of Rolldown. This is the
+ * 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}.
+ */
+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}.
+     */
+    buildOrThrow(options: BuildOptions): Promise<BuildResult>;
+    build(options: BuildOptions): Promise<BuildResult>;
+    resolve(importPath: string, rootDir: string): string;
+    getTranspileOptions(profile: BuildTranspileProfile): BuildTranspileOptions;
+}
+export declare function createRolldownBuildAdapter(): BuildAdapter;

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

@@ -0,0 +1,65 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { rolldown } from "rolldown";
+import {
+  buildResultFromRolldownOutput,
+  resolveRolldownOptions,
+  rewriteBrowserRuntimeImportsInOutputs,
+  rewriteNodeRuntimeImportsInOutputs,
+  toBuildLogs,
+  transpileProfileToOptions
+} from "./rolldown-adapter-helpers.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}.
+   */
+  async buildOrThrow(options) {
+    const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
+    const outdir = path.resolve(options.outdir ?? "dist/assets");
+    const plugins = options.plugins ?? [];
+    const { inputOptions, outputOptions } = resolveRolldownOptions(
+      options,
+      contextRoot,
+      outdir,
+      this.appRootRequireCache
+    );
+    const bundle = await rolldown(inputOptions);
+    const output = await bundle.write(outputOptions);
+    await bundle.close();
+    const baseResult = buildResultFromRolldownOutput(output, outdir, contextRoot);
+    return rewriteNodeRuntimeImportsInOutputs(
+      rewriteBrowserRuntimeImportsInOutputs(baseResult, contextRoot, plugins),
+      contextRoot
+    );
+  }
+  async build(options) {
+    try {
+      return await this.buildOrThrow(options);
+    } catch (error) {
+      return {
+        success: false,
+        logs: toBuildLogs(error),
+        outputs: []
+      };
+    }
+  }
+  resolve(importPath, rootDir) {
+    return moduleRequire.resolve(importPath, { paths: [rootDir] });
+  }
+  getTranspileOptions(profile) {
+    return transpileProfileToOptions(profile);
+  }
+}
+function createRolldownBuildAdapter() {
+  return new RolldownBuildAdapter();
+}
+export {
+  RolldownBuildAdapter,
+  createRolldownBuildAdapter
+};

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

@@ -0,0 +1,82 @@
+/**
+ * DevEngine-backed build adapter for cached incremental rebuilds.
+ *
+ * @remarks
+ * Wraps Rolldown's experimental `DevEngine` to provide cached incremental
+ * rebuilds. Unlike the standard `RolldownBuildAdapter` which creates a new
+ * bundler for every build, this adapter keeps a `DevEngine` instance alive
+ * and reuses the internal module graph, resolver cache, and transform cache
+ * across builds.
+ *
+ * The adapter is designed for the HMR rebuild path where the same entrypoints
+ * are rebuilt repeatedly with small changes. For one-off production builds,
+ * use `RolldownBuildAdapter` instead.
+ *
+ * The first build creates the engine and runs it. Subsequent builds with the
+ * same plugin/target/format triple reuse the cached engine and call
+ * `triggerFullBuild()`. The cache key incorporates the context root, plugin
+ * names, target, and format; when any of those change, the cached engine is
+ * closed and a new one is created.
+ *
+ * Call `close()` to release the cached engine and free resources.
+ *
+ * @module
+ */
+import type { BuildAdapter, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from './build-adapter.js';
+/**
+ * Build adapter backed by Rolldown's DevEngine for cached incremental rebuilds.
+ */
+export declare class RolldownDevBuildAdapter implements BuildAdapter {
+    /**
+     * `'rolldown-dev'` (not `'rolldown'`) so {@link getBuildAdapterOwnership}
+     * round-trips correctly and `createBuildAdapter({ ownership })` can
+     * re-select this class.
+     */
+    readonly ownership: "rolldown-dev";
+    private cachedEngine;
+    private engineInstanceCount;
+    private readonly pendingBuilds;
+    private readonly appRootRequireCache;
+    /**
+     * Stable key over the inputs that affect the engine configuration.
+     * Plugin order is intentionally not part of the key: two plugin
+     * sets with the same names are interchangeable for caching.
+     */
+    private getCacheKey;
+    /**
+     * Returns the cached engine, creating a new one when the cache
+     * key changes. On a cache miss the prior engine is closed and
+     * {@link engineInstanceCount} is incremented.
+     */
+    private getOrCreateEngine;
+    /**
+     * Triggers a build on the cached engine and returns the next
+     * `RolldownOutput` delivered to `onOutput`.
+     *
+     * First call after engine creation invokes `engine.run`; subsequent
+     * calls invoke `engine.triggerFullBuild` and reuse the cached
+     * module graph, resolver, and transform caches.
+     *
+     * If the trigger itself throws, the queued build is removed so
+     * the next `build()` does not consume a stale slot.
+     */
+    private runBuild;
+    /** Throws on error; see {@link build} for the no-throw variant. */
+    buildOrThrow(options: BuildOptions): Promise<BuildResult>;
+    build(options: BuildOptions): Promise<BuildResult>;
+    resolve(importPath: string, rootDir: string): string;
+    getTranspileOptions(profile: BuildTranspileProfile): BuildTranspileOptions;
+    /**
+     * Closes the cached DevEngine and rejects any in-flight builds
+     * with `'DevBuildAdapter closed'`.
+     *
+     * @remarks
+     * Not on the {@link BuildAdapter} interface, so it is only
+     * reachable through the concrete class. The adapter is meant to
+     * live for the process lifetime; this is for explicit teardown.
+     */
+    close(): Promise<void>;
+    /** Test-only: number of engines created over the adapter's lifetime. */
+    getEngineInstanceCountForTests(): number;
+}
+export declare function createRolldownDevBuildAdapter(): RolldownDevBuildAdapter;

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

@@ -0,0 +1,166 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { dev } from "rolldown/experimental";
+import {
+  buildResultFromRolldownOutput,
+  resolveRolldownOptions,
+  rewriteBrowserRuntimeImportsInOutputs,
+  toBuildLogs,
+  transpileProfileToOptions
+} from "./rolldown-adapter-helpers.js";
+const moduleRequire = createRequire(import.meta.url);
+class RolldownDevBuildAdapter {
+  /**
+   * `'rolldown-dev'` (not `'rolldown'`) so {@link getBuildAdapterOwnership}
+   * round-trips correctly and `createBuildAdapter({ ownership })` can
+   * re-select this class.
+   */
+  ownership = "rolldown-dev";
+  cachedEngine;
+  engineInstanceCount = 0;
+  pendingBuilds = [];
+  appRootRequireCache = /* @__PURE__ */ new Map();
+  /**
+   * Stable key over the inputs that affect the engine configuration.
+   * Plugin order is intentionally not part of the key: two plugin
+   * sets with the same names are interchangeable for caching.
+   */
+  getCacheKey(plugins, contextRoot, target, format) {
+    const pluginNames = plugins.map((p) => p.name).join(":");
+    return `${contextRoot}::${pluginNames}::${target ?? "default"}::${format ?? "esm"}`;
+  }
+  /**
+   * Returns the cached engine, creating a new one when the cache
+   * key changes. On a cache miss the prior engine is closed and
+   * {@link engineInstanceCount} is incremented.
+   */
+  async getOrCreateEngine(options, contextRoot) {
+    const bundlePlugins = options.plugins ?? [];
+    const cacheKey = this.getCacheKey(bundlePlugins, contextRoot, options.target, options.format);
+    if (this.cachedEngine) {
+      const existingKey = this.getCacheKey(
+        this.cachedEngine.bundlePlugins,
+        this.cachedEngine.contextRoot,
+        options.target,
+        options.format
+      );
+      if (existingKey === cacheKey) {
+        return this.cachedEngine;
+      }
+      await this.cachedEngine.engine.close();
+      this.cachedEngine = void 0;
+    }
+    const outdir = path.resolve(options.outdir ?? "dist/assets");
+    const { inputOptions, outputOptions } = resolveRolldownOptions(
+      options,
+      contextRoot,
+      outdir,
+      this.appRootRequireCache
+    );
+    const engine = await dev(inputOptions, outputOptions, {
+      rebuildStrategy: "never",
+      onOutput: (result) => {
+        if (result instanceof Error) {
+          return;
+        }
+        const next = this.pendingBuilds.shift();
+        if (next) {
+          next.resolve(result);
+        }
+      }
+    });
+    this.cachedEngine = {
+      engine,
+      engineStarted: false,
+      contextRoot,
+      bundlePlugins
+    };
+    this.engineInstanceCount += 1;
+    return this.cachedEngine;
+  }
+  /**
+   * Triggers a build on the cached engine and returns the next
+   * `RolldownOutput` delivered to `onOutput`.
+   *
+   * First call after engine creation invokes `engine.run`; subsequent
+   * calls invoke `engine.triggerFullBuild` and reuse the cached
+   * module graph, resolver, and transform caches.
+   *
+   * If the trigger itself throws, the queued build is removed so
+   * the next `build()` does not consume a stale slot.
+   */
+  async runBuild(cached) {
+    const outputPromise = new Promise((resolve, reject) => {
+      this.pendingBuilds.push({ resolve, reject });
+    });
+    try {
+      if (!cached.engineStarted) {
+        cached.engineStarted = true;
+        await cached.engine.run();
+      } else {
+        cached.engine.triggerFullBuild();
+      }
+    } catch (error) {
+      this.pendingBuilds.shift();
+      throw error;
+    }
+    return outputPromise;
+  }
+  /** Throws on error; see {@link build} for the no-throw variant. */
+  async buildOrThrow(options) {
+    const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
+    const outdir = path.resolve(options.outdir ?? "dist/assets");
+    const plugins = options.plugins ?? [];
+    const cached = await this.getOrCreateEngine(options, contextRoot);
+    const output = await this.runBuild(cached);
+    const baseResult = buildResultFromRolldownOutput(output, outdir, contextRoot);
+    return rewriteBrowserRuntimeImportsInOutputs(baseResult, contextRoot, plugins);
+  }
+  async build(options) {
+    try {
+      return await this.buildOrThrow(options);
+    } catch (error) {
+      return {
+        success: false,
+        logs: toBuildLogs(error),
+        outputs: []
+      };
+    }
+  }
+  resolve(importPath, rootDir) {
+    return moduleRequire.resolve(importPath, { paths: [rootDir] });
+  }
+  getTranspileOptions(profile) {
+    return transpileProfileToOptions(profile);
+  }
+  /**
+   * Closes the cached DevEngine and rejects any in-flight builds
+   * with `'DevBuildAdapter closed'`.
+   *
+   * @remarks
+   * Not on the {@link BuildAdapter} interface, so it is only
+   * reachable through the concrete class. The adapter is meant to
+   * live for the process lifetime; this is for explicit teardown.
+   */
+  async close() {
+    if (this.cachedEngine) {
+      await this.cachedEngine.engine.close();
+      this.cachedEngine = void 0;
+    }
+    while (this.pendingBuilds.length > 0) {
+      const pending = this.pendingBuilds.shift();
+      pending?.reject(new Error("DevBuildAdapter closed"));
+    }
+  }
+  /** Test-only: number of engines created over the adapter's lifetime. */
+  getEngineInstanceCountForTests() {
+    return this.engineInstanceCount;
+  }
+}
+function createRolldownDevBuildAdapter() {
+  return new RolldownDevBuildAdapter();
+}
+export {
+  RolldownDevBuildAdapter,
+  createRolldownDevBuildAdapter
+};

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

@@ -0,0 +1,59 @@
+/**
+ * Bundler plugin bridge.
+ *
+ * @remarks
+ * Translates an array of `EcoBuildPlugin` instances (the runtime-agnostic
+ * plugin contract used by Ecopages processors and integrations) into
+ * the bundler's native `Plugin` array. The bridge exposes the same
+ * three hooks (`onResolve`, `onLoad`, `module`) the `EcoBuildPlugin`
+ * contract uses, but maps them to the bundler's `resolveId`/`load`
+ * hooks.
+ *
+ * The shared `EcoBuildPlugin` contract stays the boundary between
+ * integrations and bundler backends.
+ *
+ * **Namespace handling.**
+ *
+ * The shared `EcoBuildPlugin` contract scopes `onResolve`/`onLoad`
+ * handlers with a `namespace` string. The bundler encodes namespaces
+ * into the module id (no separate field). The bridge prepends
+ * `<namespace>:` to the resolved id when the result includes a
+ * namespace, and matches `onLoad`/`onResolve` filters against that
+ * prefix. The bridge strips the prefix before forwarding the id back
+ * to the callback so plugin code keeps seeing the same `path` shape
+ * it did on the historical contract.
+ *
+ * **Plugin ordering is semantically significant.**
+ *
+ * The bundler's `resolveId` and `load` are "first" hooks: the first
+ * plugin that returns a non-null value wins. Because the bridge
+ * translates each `EcoBuildPlugin` into its own bundler plugin and
+ * preserves the array order, the position of each plugin in the
+ * `plugins` array determines its priority:
+ *
+ * - **Index 0** has the highest priority.
+ * - **Last index** has the lowest priority.
+ *
+ * When adding new integrations or processors, ensure security-critical
+ * plugins (e.g. `ecopages-client-graph-boundary`) are placed **before**
+ * general-purpose loaders in the array so they always get first refusal
+ * on every source file.
+ */
+import type { Plugin } from 'rolldown';
+import type { EcoBuildPlugin } from './build-types.js';
+/**
+ * Creates a Rolldown `Plugin` array that drives the supplied
+ * `EcoBuildPlugin` instances.
+ *
+ * All eco plugins are merged into a single Rolldown plugin to minimize
+ * Rust→JS FFI overhead. Rolldown calls every hook for every module when
+ * there is no static filter, so N separate plugins would cause N
+ * `resolveId` + N `load` calls per module. Consolidating into one
+ * plugin reduces that to 1 call each, with JavaScript-side filtering
+ * routing to the correct eco plugin callback.
+ *
+ * Plugin ordering is preserved: registrations from earlier eco plugins
+ * are checked before registrations from later ones, matching the
+ * original per-plugin priority semantics.
+ */
+export declare function createRolldownPluginBridge(plugins: EcoBuildPlugin[], contextRoot: string): Plugin[];

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

@@ -0,0 +1,199 @@
+import path from "node:path";
+import { escapeRegExp } from "./browser-runtime-plugin-helpers.js";
+const NAMESPACE_SEPARATOR = ":";
+function joinNamespace(namespace, value) {
+  return namespace ? `${namespace}${NAMESPACE_SEPARATOR}${value}` : value;
+}
+function splitNamespace(id) {
+  const separatorIndex = id.indexOf(NAMESPACE_SEPARATOR);
+  if (separatorIndex <= 0) {
+    return { namespace: void 0, path: id };
+  }
+  return {
+    namespace: id.slice(0, separatorIndex),
+    path: id.slice(separatorIndex + 1)
+  };
+}
+function inferRolldownModuleTypeFromPath(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  switch (extension) {
+    case ".ts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    case ".json":
+      return "json";
+    case ".css":
+      return "css";
+    default:
+      return "js";
+  }
+}
+function normalizeRolldownModuleType(loader) {
+  switch (loader) {
+    case "js":
+    case "jsx":
+    case "ts":
+    case "tsx":
+    case "json":
+    case "css":
+    case "text":
+    case "base64":
+    case "dataurl":
+    case "binary":
+    case "empty":
+      return loader;
+    case "global-css":
+    case "local-css":
+      return "css";
+    case "file":
+    case "copy":
+      return "asset";
+    default:
+      return void 0;
+  }
+}
+function convertLoadResultToModuleSource(result) {
+  if (result.loader === "object" && result.exports && typeof result.exports === "object") {
+    return Object.entries(result.exports).map(
+      ([key, value]) => key === "default" ? `export default ${JSON.stringify(value)};` : `export const ${key} = ${JSON.stringify(value)};`
+    ).join("\n");
+  }
+  return void 0;
+}
+function buildIdFilter(filter, namespace) {
+  if (!namespace) {
+    return filter;
+  }
+  return new RegExp(`^${escapeRegExp(namespace)}${NAMESPACE_SEPARATOR}${filter.source.slice(1)}`);
+}
+function resolvePluginPath(value, importer, contextRoot) {
+  if (path.isAbsolute(value)) {
+    return value;
+  }
+  if (value.startsWith(".") || value.startsWith("..")) {
+    const baseDir = importer ? path.dirname(importer) : contextRoot;
+    return path.resolve(baseDir, value);
+  }
+  return value;
+}
+function convertPluginOnLoadResult(args, result) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const candidate = result;
+  const { path: sourcePath } = splitNamespace(args.id);
+  const sourceFromExports = convertLoadResultToModuleSource(candidate);
+  if (sourceFromExports) {
+    const description = {
+      code: sourceFromExports,
+      moduleType: "js"
+    };
+    return description;
+  }
+  if (typeof candidate.contents === "string" || candidate.contents instanceof Uint8Array) {
+    const code = typeof candidate.contents === "string" ? candidate.contents : new TextDecoder().decode(candidate.contents);
+    const description = {
+      code,
+      moduleType: normalizeRolldownModuleType(candidate.loader) ?? inferRolldownModuleTypeFromPath(sourcePath)
+    };
+    return description;
+  }
+  return void 0;
+}
+function convertPluginOnResolveResult(result, importer, contextRoot) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const candidate = result;
+  if (typeof candidate.path !== "string" && typeof candidate.namespace !== "string") {
+    if (typeof candidate.external !== "boolean") {
+      return void 0;
+    }
+  }
+  const partial = { id: "" };
+  if (typeof candidate.path === "string") {
+    partial.id = joinNamespace(candidate.namespace, resolvePluginPath(candidate.path, importer, contextRoot));
+  } else if (typeof candidate.namespace === "string") {
+    partial.id = joinNamespace(candidate.namespace, "");
+  }
+  if (typeof candidate.external === "boolean") {
+    partial.external = candidate.external;
+  }
+  return partial;
+}
+function createRolldownPluginBridge(plugins, contextRoot) {
+  if (plugins.length === 0) {
+    return [];
+  }
+  const moduleCounter = { value: 0 };
+  const resolveRegistrations = [];
+  const loadRegistrations = [];
+  const registerResolve = (filter, callback) => {
+    resolveRegistrations.push({ filter, callback });
+  };
+  const registerLoad = (filter, callback) => {
+    loadRegistrations.push({ filter, callback });
+  };
+  const resolveIdHandler = async (source, importer, _extraOptions) => {
+    for (const { filter, callback } of resolveRegistrations) {
+      if (!filter.test(source)) {
+        continue;
+      }
+      const { namespace, path: sourcePath } = splitNamespace(source);
+      const result = await callback({ path: sourcePath, importer, namespace });
+      const converted = convertPluginOnResolveResult(result, importer, contextRoot);
+      if (converted !== void 0) {
+        return converted;
+      }
+    }
+    return void 0;
+  };
+  const loadHandler = async (id) => {
+    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 converted = convertPluginOnLoadResult({ id }, result);
+      if (converted !== void 0) {
+        return converted;
+      }
+    }
+    return void 0;
+  };
+  const plugin = {
+    name: "ecopages-plugin-bridge",
+    buildStart: async () => {
+      for (const ecoPlugin of plugins) {
+        const bridge = {
+          onResolve: (options, callback) => {
+            registerResolve(buildIdFilter(options.filter, options.namespace), callback);
+          },
+          onLoad: (options, callback) => {
+            registerLoad(buildIdFilter(options.filter, options.namespace), callback);
+          },
+          module: (specifier, callback) => {
+            const namespace = `ecopages-module-${moduleCounter.value}`;
+            moduleCounter.value += 1;
+            const filter = new RegExp(`^${escapeRegExp(specifier)}$`);
+            registerResolve(filter, async () => ({
+              path: joinNamespace(namespace, specifier)
+            }));
+            registerLoad(buildIdFilter(/.*/, namespace), async () => callback());
+          }
+        };
+        await ecoPlugin.setup(bridge);
+      }
+    },
+    resolveId: resolveIdHandler,
+    load: loadHandler
+  };
+  return [plugin];
+}
+export {
+  createRolldownPluginBridge
+};

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

@@ -1,13 +1,21 @@
-import type { EcoPagesAppConfig } from '../internal-types.js';
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
 import { type BuildExecutor } from './build-adapter.js';
 /**
  * Installs the app-owned runtime build executor for one app instance.
  *
  * @remarks
- * This is the single coordinator boundary for runtime executor ownership across
- * adapters. It preserves an existing development coordinator when available and
- * always applies app server build plugins through one shared path.
+ * 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}.
  */
-export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig, options: {
-    development: boolean;
-}): BuildExecutor;
+export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;

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

@@ -2,16 +2,15 @@ import {
   getAppBuildAdapter,
   getAppBuildExecutor,
   getAppServerBuildPlugins,
-  setAppBuildExecutor
+  setAppBuildExecutor,
+  withBuildExecutorPlugins
 } from "./build-adapter.js";
-import { createOrReuseAppBuildExecutor } from "./dev-build-coordinator.js";
-function installAppRuntimeBuildExecutor(appConfig, options) {
-  const buildExecutor = createOrReuseAppBuildExecutor({
-    development: options.development,
-    adapter: getAppBuildAdapter(appConfig),
-    currentExecutor: getAppBuildExecutor(appConfig),
-    getPlugins: () => getAppServerBuildPlugins(appConfig)
-  });
+import { SerializedBuildExecutor } from "./serialized-build-executor.js";
+function installAppRuntimeBuildExecutor(appConfig) {
+  const baseExecutor = getAppBuildExecutor(appConfig) ?? getAppBuildAdapter(appConfig);
+  const buildExecutor = new SerializedBuildExecutor(
+    withBuildExecutorPlugins(baseExecutor, () => getAppServerBuildPlugins(appConfig))
+  );
   setAppBuildExecutor(appConfig, buildExecutor);
   return buildExecutor;
 }

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

@@ -0,0 +1,3 @@
+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;