@ecopages/core 0.2.0-alpha.53 → 0.2.0-alpha.55

package/src/build/build-adapter.js

@@ -1,487 +1,38 @@
 import { mergeBrowserRuntimeManifests } from "./browser-runtime-manifest.js";
-import {
-  collectBrowserRuntimeImportRewriteMap,
-  rewriteBrowserRuntimeImports
-} from "./browser-runtime-import-rewrite-plugin.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 { EsbuildBuildAdapter } from "./esbuild-build-adapter.js";
-import { getBunRuntime } from "../utils/runtime.js";
-import fs from "node:fs";
-import path from "node:path";
-import { EsbuildBuildAdapter as EsbuildBuildAdapter2 } from "./esbuild-build-adapter.js";
-function transpileProfileToOptions(profile) {
-  switch (profile) {
-    case "browser-script":
-      return {
-        target: "browser",
-        format: "esm",
-        sourcemap: "none"
-      };
-    case "hmr-runtime":
-      return {
-        target: "browser",
-        format: "esm",
-        sourcemap: "none"
-      };
-    case "hmr-entrypoint":
-      return {
-        target: "browser",
-        format: "esm",
-        sourcemap: "none"
-      };
-  }
-}
-class BunBuildAdapter {
-  ownership = "bun-native";
-  fallbackAdapter = new EsbuildBuildAdapter();
-  getPluginsForBuild(additionalPlugins) {
-    const byName = /* @__PURE__ */ new Map();
-    for (const plugin of additionalPlugins ?? []) {
-      if (!byName.has(plugin.name)) {
-        byName.set(plugin.name, plugin);
-      }
-    }
-    return Array.from(byName.values());
-  }
-  escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  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;
-  }
-  inferLoaderFromPath(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";
-    }
-  }
-  normalizeBunLoader(loader) {
-    switch (loader) {
-      case "js":
-      case "jsx":
-      case "ts":
-      case "tsx":
-      case "json":
-      case "toml":
-      case "text":
-      case "file":
-      case "css":
-        return loader;
-      case "global-css":
-      case "local-css":
-        return "css";
-      default:
-        return void 0;
-    }
-  }
-  convertLoadResultToModuleSource(result) {
-    if (!result || typeof result !== "object") {
-      return void 0;
-    }
-    const candidate = result;
-    if (typeof candidate.contents === "string") {
-      return candidate.contents;
-    }
-    if (candidate.loader === "object" && candidate.exports && typeof candidate.exports === "object") {
-      return Object.entries(candidate.exports).map(
-        ([key, value]) => key === "default" ? `export default ${JSON.stringify(value)};` : `export const ${key} = ${JSON.stringify(value)};`
-      ).join("\n");
-    }
-    return void 0;
-  }
-  convertPluginOnLoadResult(args, result) {
-    if (!result || typeof result !== "object") {
-      return void 0;
-    }
-    const candidate = result;
-    const sourceFromExports = candidate.loader === "object" && candidate.exports && typeof candidate.exports === "object" ? this.convertLoadResultToModuleSource(candidate) : void 0;
-    if (sourceFromExports) {
-      return {
-        contents: sourceFromExports,
-        loader: "js",
-        ...typeof candidate.resolveDir === "string" ? { resolveDir: candidate.resolveDir } : {}
-      };
-    }
-    if (typeof candidate.contents === "string" || candidate.contents instanceof Uint8Array) {
-      return {
-        contents: candidate.contents,
-        loader: this.normalizeBunLoader(candidate.loader) ?? this.inferLoaderFromPath(args.path),
-        ...typeof candidate.resolveDir === "string" ? { resolveDir: candidate.resolveDir } : {}
-      };
-    }
-    return void 0;
-  }
-  createEcoPluginBridge(plugins, contextRoot) {
-    return {
-      name: "ecopages-plugin-bridge",
-      setup: async (build2) => {
-        let moduleCounter = 0;
-        const bridge = {
-          onResolve: (options, callback) => {
-            build2.onResolve(options, async (args) => {
-              const result = await callback({
-                path: args.path,
-                importer: args.importer,
-                namespace: args.namespace
-              });
-              if (!result || typeof result !== "object") {
-                return void 0;
-              }
-              return {
-                ...typeof result.path === "string" ? { path: this.resolvePluginPath(result.path, args.importer, contextRoot) } : {},
-                ...typeof result.namespace === "string" ? { namespace: result.namespace } : {},
-                ...typeof result.external === "boolean" ? { external: result.external } : {}
-              };
-            });
-          },
-          onLoad: (options, callback) => {
-            build2.onLoad(
-              options,
-              async (args) => this.convertPluginOnLoadResult(
-                { path: args.path },
-                await callback({
-                  path: args.path,
-                  namespace: args.namespace
-                })
-              )
-            );
-          },
-          module: (specifier, callback) => {
-            const namespace = `ecopages-module-${moduleCounter}`;
-            moduleCounter += 1;
-            const filter = new RegExp(`^${this.escapeRegExp(specifier)}$`);
-            build2.onResolve({ filter }, async () => ({
-              path: specifier,
-              namespace
-            }));
-            build2.onLoad(
-              { filter, namespace },
-              async () => this.convertPluginOnLoadResult({ path: specifier }, await callback())
-            );
-          }
-        };
-        for (const plugin of plugins) {
-          await plugin.setup(bridge);
-        }
-      }
-    };
+import { createRolldownBuildAdapter } from "./rolldown-build-adapter.js";
+function mergeBuildExecutorPlugins(existing, appPlugins) {
+  if (!existing || existing.length === 0) {
+    return appPlugins;
   }
-  toBuildLogs(error) {
-    if (error instanceof Error) {
-      return [{ message: error.message }];
-    }
-    return [{ message: "Unknown Bun build error" }];
-  }
-  mapBunTarget(value) {
-    return value === "browser" ? "browser" : "bun";
-  }
-  mapBunFormat(value) {
-    switch (value) {
-      case "cjs":
-        return "cjs";
-      case "esm":
-      default:
-        return "esm";
-    }
-  }
-  getOutputExtension(options, entrypointPath) {
-    const entryExtension = path.extname(entrypointPath).toLowerCase();
-    if (entryExtension === ".css") {
-      return ".css";
-    }
-    if (entryExtension === ".json") {
-      return ".json";
-    }
-    if (entryExtension === ".toml") {
-      return ".toml";
-    }
-    if (options.target !== "browser") {
-      if (options.format === "cjs") {
-        return ".cjs";
-      }
-      if (options.format === "esm") {
-        return ".mjs";
-      }
-    }
-    return ".js";
+  const byName = /* @__PURE__ */ new Map();
+  for (const plugin of existing) {
+    byName.set(plugin.name, plugin);
   }
-  resolveConcreteOutputPath(outputPath) {
-    if (fs.existsSync(outputPath)) {
-      return outputPath;
-    }
-    for (const extension of [".js", ".mjs", ".cjs"]) {
-      const outputPathWithExtension = `${outputPath}${extension}`;
-      if (fs.existsSync(outputPathWithExtension)) {
-        return outputPathWithExtension;
-      }
-    }
-    if (!outputPath.includes("[hash]")) {
-      return outputPath;
-    }
-    const directory = path.dirname(outputPath);
-    if (!fs.existsSync(directory)) {
-      return void 0;
-    }
-    const basenamePattern = path.basename(outputPath);
-    const matcher = new RegExp(`^${this.escapeRegExp(basenamePattern).replace(/\\\[hash\\\]/g, "(.+)")}$`);
-    const matches = fs.readdirSync(directory).filter((candidate) => matcher.test(candidate)).sort();
-    if (matches.length === 0) {
-      return void 0;
-    }
-    return path.join(directory, matches[0]);
-  }
-  normalizePathForMatch(filePath) {
-    return path.normalize(filePath).split(path.sep).join("/");
-  }
-  normalizeOutputPathForMatch(outputPath, templatePath) {
-    const normalizedOutputPath = path.normalize(outputPath);
-    const templateExtension = path.extname(templatePath);
-    if (!templateExtension) {
-      return normalizedOutputPath;
-    }
-    if (templateExtension === ".js") {
-      if (this.hasJavaScriptExtension(normalizedOutputPath)) {
-        return path.normalize(normalizedOutputPath.replace(/\.(?:[cm]?js)$/u, ".js"));
-      }
-      return path.normalize(`${normalizedOutputPath}.js`);
-    }
-    if (normalizedOutputPath.endsWith(templateExtension)) {
-      return normalizedOutputPath;
-    }
-    return path.normalize(`${normalizedOutputPath}${templateExtension}`);
+  for (const plugin of appPlugins) {
+    byName.set(plugin.name, plugin);
   }
-  extractTemplateHashTokens(templatePath, candidatePath) {
-    const normalizedTemplatePath = this.normalizePathForMatch(templatePath);
-    const normalizedCandidatePath = this.normalizePathForMatch(
-      this.normalizeOutputPathForMatch(candidatePath, templatePath)
-    );
-    const matcher = new RegExp(
-      `^${this.escapeRegExp(normalizedTemplatePath).replace(/\\\[hash\\\]/g, "([^/]+)")}$`
-    );
-    const match = normalizedCandidatePath.match(matcher);
-    if (!match) {
-      return void 0;
-    }
-    return match.slice(1);
-  }
-  applyTemplateHashTokens(templatePath, hashTokens) {
-    const hashTokenCount = templatePath.match(/\[hash\]/g)?.length ?? 0;
-    if (hashTokenCount !== hashTokens.length) {
-      return void 0;
-    }
-    if (hashTokenCount === 0) {
-      return templatePath;
-    }
-    let hashTokenIndex = 0;
-    return templatePath.replace(/\[hash\]/g, () => hashTokens[hashTokenIndex++] ?? "");
-  }
-  resolveTemplatedOutputPath(options, entrypointPath) {
-    if (!options.outdir) {
-      return void 0;
-    }
-    const template = typeof options.naming === "string" ? options.naming : "[dir]/[name]";
-    const outdir = path.resolve(options.outdir);
-    const outputExtension = this.getOutputExtension(options, entrypointPath);
-    const relativeBase = path.resolve(options.outbase ?? options.root ?? process.cwd());
-    const relativeEntrypoint = path.relative(relativeBase, entrypointPath);
-    const relativeDir = path.dirname(relativeEntrypoint);
-    const dirToken = relativeDir === "." ? "" : relativeDir.split(path.sep).join("/");
-    const nameToken = path.basename(relativeEntrypoint, path.extname(relativeEntrypoint));
-    const extToken = outputExtension.replace(/^\./, "");
-    let resolvedPath = template.replaceAll("[dir]", dirToken).replaceAll("[name]", nameToken).replaceAll("[ext]", extToken);
-    if (outputExtension && !resolvedPath.endsWith(outputExtension)) {
-      resolvedPath += outputExtension;
-    }
-    resolvedPath = resolvedPath.replace(/^\.\//, "");
-    return path.join(outdir, resolvedPath);
-  }
-  relocateOutputFile(currentPath, targetPath) {
-    if (currentPath === targetPath || !fs.existsSync(currentPath)) {
-      return fs.existsSync(targetPath) ? targetPath : currentPath;
-    }
-    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-    fs.rmSync(targetPath, { force: true });
-    fs.renameSync(currentPath, targetPath);
-    return targetPath;
-  }
-  hasJavaScriptExtension(outputPath) {
-    return /\.(?:[cm]?js)$/u.test(outputPath);
-  }
-  rewriteBrowserRuntimeImportsInOutputs(result, plugins) {
-    if (!result.success || result.outputs.length === 0) {
-      return result;
-    }
-    const specifierMap = collectBrowserRuntimeImportRewriteMap(plugins);
-    if (specifierMap.size === 0) {
-      return result;
-    }
-    for (const output of result.outputs) {
-      if (!this.hasJavaScriptExtension(output.path) || !fs.existsSync(output.path)) {
-        continue;
-      }
-      const code = fs.readFileSync(output.path, "utf-8");
-      const rewritten = rewriteBrowserRuntimeImports(code, specifierMap, output.path);
-      if (rewritten !== code) {
-        fs.writeFileSync(output.path, rewritten);
-      }
-    }
-    return result;
-  }
-  findOutputMatchForEntrypoint(options, entrypointPath, outputs, usedOutputIndexes) {
-    const expectedOutputPath = this.resolveTemplatedOutputPath(options, entrypointPath);
-    if (!expectedOutputPath) {
-      return void 0;
-    }
-    const expectedMatchPaths = [expectedOutputPath];
-    if (options.outbase) {
-      const bunRootRelativeOutputPath = this.resolveTemplatedOutputPath(
-        { ...options, outbase: void 0 },
-        entrypointPath
-      );
-      if (bunRootRelativeOutputPath && bunRootRelativeOutputPath !== expectedOutputPath) {
-        expectedMatchPaths.push(bunRootRelativeOutputPath);
-      }
-    }
-    for (const [outputIndex, output] of outputs.entries()) {
-      if (usedOutputIndexes.has(outputIndex)) {
-        continue;
-      }
-      for (const matchPath of expectedMatchPaths) {
-        const hashTokens = this.extractTemplateHashTokens(matchPath, output.concretePath);
-        if (!hashTokens) {
-          continue;
-        }
-        const targetPath = this.applyTemplateHashTokens(expectedOutputPath, hashTokens);
-        if (!targetPath) {
-          continue;
-        }
-        usedOutputIndexes.add(outputIndex);
-        return { outputIndex, targetPath };
-      }
-    }
-    return void 0;
-  }
-  normalizeBunOutputs(result, options) {
-    if (!result.success || result.outputs.length === 0) {
-      return result;
-    }
-    const normalizedOutputs = result.outputs.map((output) => ({
-      concretePath: this.resolveConcreteOutputPath(output.path) ?? output.path
-    }));
-    const matchedTargetsByIndex = /* @__PURE__ */ new Map();
-    const usedOutputIndexes = /* @__PURE__ */ new Set();
-    for (const entrypointPath of options.entrypoints) {
-      const matchedOutput = this.findOutputMatchForEntrypoint(
-        options,
-        entrypointPath,
-        normalizedOutputs,
-        usedOutputIndexes
-      );
-      if (matchedOutput) {
-        matchedTargetsByIndex.set(matchedOutput.outputIndex, matchedOutput.targetPath);
+  return Array.from(byName.values());
+}
+function withBuildExecutorPlugins(executor, getPlugins) {
+  return {
+    async build(options) {
+      const appPlugins = getPlugins();
+      if (appPlugins.length === 0) {
+        return executor.build(options);
       }
-    }
-    return {
-      ...result,
-      outputs: normalizedOutputs.map((output, index) => {
-        const expectedOutputPath = matchedTargetsByIndex.get(index);
-        const concreteOutputPath = output.concretePath;
-        if (expectedOutputPath) {
-          return {
-            path: this.relocateOutputFile(concreteOutputPath, expectedOutputPath)
-          };
-        }
-        if (this.hasJavaScriptExtension(concreteOutputPath)) {
-          return {
-            path: concreteOutputPath
-          };
-        }
-        const normalizedPath = `${concreteOutputPath}.js`;
-        return {
-          path: this.relocateOutputFile(concreteOutputPath, normalizedPath)
-        };
-      })
-    };
-  }
-  async build(options) {
-    const bun = getBunRuntime();
-    if (!bun) {
-      return this.fallbackAdapter.build(options);
-    }
-    try {
-      const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
-      const outdir = path.resolve(options.outdir ?? "dist/assets");
-      const tsconfigPath = path.join(contextRoot, "tsconfig.json");
-      const tsconfigExists = fs.existsSync(tsconfigPath);
-      const plugins = this.getPluginsForBuild(options.plugins);
-      const result = await bun.build({
-        entrypoints: options.entrypoints,
-        outdir,
-        root: contextRoot,
-        naming: typeof options.naming === "string" ? options.naming : void 0,
-        define: options.define,
-        external: options.external,
-        format: this.mapBunFormat(options.format),
-        target: this.mapBunTarget(options.target),
-        sourcemap: options.sourcemap,
-        splitting: !!options.splitting,
-        minify: !!options.minify,
-        packages: options.target !== "browser" && options.externalPackages !== false ? "external" : void 0,
-        tsconfig: tsconfigExists ? tsconfigPath : void 0,
-        jsx: options.jsx,
-        plugins: plugins.length > 0 ? [this.createEcoPluginBridge(plugins, contextRoot)] : void 0
+      return executor.build({
+        ...options,
+        plugins: mergeBuildExecutorPlugins(options.plugins, appPlugins)
       });
-      return this.rewriteBrowserRuntimeImportsInOutputs(
-        this.normalizeBunOutputs(
-          {
-            success: result.success,
-            logs: result.logs.map((log) => ({ message: log.message })),
-            outputs: result.outputs.map((output) => ({ path: output.path }))
-          },
-          options
-        ),
-        plugins
-      );
-    } catch (error) {
-      return {
-        success: false,
-        logs: this.toBuildLogs(error),
-        outputs: []
-      };
     }
-  }
-  resolve(importPath, rootDir) {
-    const bun = getBunRuntime();
-    if (!bun) {
-      return this.fallbackAdapter.resolve(importPath, rootDir);
-    }
-    return bun.resolveSync(importPath, rootDir);
-  }
-  getTranspileOptions(profile) {
-    return transpileProfileToOptions(profile);
-  }
+  };
 }
 function createHostOwnedBuildError(methodName) {
   return new Error(
@@ -500,29 +51,26 @@ class ViteHostBuildAdapter {
     throw createHostOwnedBuildError("derive transpile options");
   }
 }
-function createBunBuildAdapter() {
-  return new BunBuildAdapter();
-}
 function createViteHostBuildAdapter() {
   return new ViteHostBuildAdapter();
 }
 function createBuildAdapter(options) {
-  switch (options?.ownership ?? "bun-native") {
+  switch (options?.ownership ?? "rolldown") {
     case "vite-host":
       return createViteHostBuildAdapter();
-    case "bun-native":
+    case "rolldown":
     default:
-      return createBunBuildAdapter();
+      return createRolldownBuildAdapter();
   }
 }
-const defaultBunBuildAdapter = createBuildAdapter({ ownership: "bun-native" });
+const defaultRolldownBuildAdapter = createBuildAdapter({ ownership: "rolldown" });
 const defaultViteHostBuildAdapter = createBuildAdapter({ ownership: "vite-host" });
-const defaultBuildAdapter = defaultBunBuildAdapter;
-function getDefaultBuildAdapter(ownership = "bun-native") {
-  return ownership === "vite-host" ? defaultViteHostBuildAdapter : defaultBunBuildAdapter;
+const defaultBuildAdapter = defaultRolldownBuildAdapter;
+function getDefaultBuildAdapter(ownership = "rolldown") {
+  return ownership === "vite-host" ? defaultViteHostBuildAdapter : defaultRolldownBuildAdapter;
 }
 function getBuildAdapterOwnership(buildAdapter) {
-  return buildAdapter?.ownership ?? "bun-native";
+  return buildAdapter?.ownership ?? "rolldown";
 }
 function getAppBuildOwnership(appConfig) {
   return appConfig.runtime?.buildOwnership ?? getBuildAdapterOwnership(appConfig.runtime?.buildAdapter);
@@ -619,7 +167,22 @@ function getAppServerBuildPlugins(appConfig) {
   return getServerBuildPlugins(getAppBuildManifest(appConfig));
 }
 function getAppBrowserBuildPlugins(appConfig) {
-  return getBrowserBuildPlugins(getAppBuildManifest(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, "-")}`
+    })
+  );
 }
 function getAppBuildExecutor(appConfig) {
   return appConfig.runtime?.buildExecutor ?? getAppBuildAdapter(appConfig);
@@ -630,27 +193,32 @@ function setAppBuildExecutor(appConfig, buildExecutor) {
     buildExecutor
   };
 }
-function build(options, executor = defaultBunBuildAdapter) {
-  return executor.build(options);
+function build(options, executor = defaultRolldownBuildAdapter) {
+  return executor.build(options).then((result) => {
+    if (result.success) {
+      normalizeNodeRuntimeBuildOutputs(
+        result.outputs.map((output) => output.path),
+        options.root ?? process.cwd()
+      );
+    }
+    return result;
+  });
 }
 function getTranspileOptions(profile) {
-  return defaultBunBuildAdapter.getTranspileOptions(profile);
+  return defaultRolldownBuildAdapter.getTranspileOptions(profile);
 }
 function getAppTranspileOptions(appConfig, profile) {
   return getAppBuildAdapter(appConfig).getTranspileOptions(profile);
 }
 export {
-  BunBuildAdapter,
-  EsbuildBuildAdapter2 as EsbuildBuildAdapter,
   ViteHostBuildAdapter,
   build,
   collectConfiguredAppBuildManifestContributions,
   createBuildAdapter,
-  createBunBuildAdapter,
   createConfiguredAppBuildManifest,
   createViteHostBuildAdapter,
   defaultBuildAdapter,
-  defaultBunBuildAdapter,
+  defaultRolldownBuildAdapter,
   defaultViteHostBuildAdapter,
   getAppBrowserBuildPlugins,
   getAppBuildAdapter,
@@ -667,5 +235,6 @@ export {
   setAppBuildManifest,
   setAppBuildOwnership,
   setupAppRuntimePlugins,
-  updateAppBuildManifest
+  updateAppBuildManifest,
+  withBuildExecutorPlugins
 };

package/src/build/build-manifest.js

@@ -1,7 +1,4 @@
-import {
-  createBrowserRuntimeImportRewritePlugin,
-  DEFAULT_BROWSER_RUNTIME_IMPORT_REWRITE_PLUGIN_NAME
-} from "./browser-runtime-import-rewrite-plugin.js";
+import { createBrowserRuntimePlugin, DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME } from "./browser-runtime-plugin.js";
 import {
   createBrowserRuntimeManifest,
   mergeBrowserRuntimeManifests
@@ -32,8 +29,8 @@ function getServerBuildPlugins(manifest) {
   return mergeEcoBuildPlugins(manifest.loaderPlugins, manifest.runtimePlugins);
 }
 function getBrowserBuildPlugins(manifest) {
-  const runtimeRewritePlugin = createBrowserRuntimeImportRewritePlugin({
-    name: DEFAULT_BROWSER_RUNTIME_IMPORT_REWRITE_PLUGIN_NAME,
+  const runtimeRewritePlugin = createBrowserRuntimePlugin({
+    name: DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME,
     manifest: getBrowserRuntimeManifest(manifest)
   });
   return mergeEcoBuildPlugins(

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

@@ -22,7 +22,7 @@ export type EcoBuildOnLoadArgs = {
     namespace?: string;
 };
 /**
- * Loader kinds supported across Bun/esbuild bridge points.
+ * Loader kinds supported by the build plugin contract.
  */
 export type EcoBuildLoader = 'base64' | 'binary' | 'copy' | 'css' | 'dataurl' | 'empty' | 'file' | 'global-css' | 'js' | 'json' | 'jsx' | 'local-css' | 'object' | 'text' | 'ts' | 'tsx';
 /**
@@ -35,7 +35,7 @@ export type EcoBuildOnLoadResult = {
     resolveDir?: string;
 };
 /**
- * Shared plugin builder contract used by Ecopages across Bun and esbuild.
+ * Plugin builder contract consumed by build adapters.
  */
 export interface EcoBuildPluginBuilder {
     onResolve(options: {

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

@@ -0,0 +1,32 @@
+/**
+ * Bundler-backed build adapter.
+ *
+ * @remarks
+ * Implements {@link BuildAdapter} on top of the bundler. This is the
+ * default adapter installed by `ConfigBuilder` and the only adapter
+ * that issues real builds in production.
+ *
+ * Responsibilities:
+ *
+ * - Map {@link BuildOptions} to the bundler's native options and
+ *   return a {@link BuildResult} (outputs + dependency graph).
+ * - Translate the runtime-agnostic `EcoBuildPlugin[]` via the bundled
+ *   plugin bridge, preserving plugin-priority order by giving each
+ *   plugin its own slot.
+ * - Run the browser-runtime-import rewriter against the emitted
+ *   JavaScript outputs when the manifest declares a rewrite map.
+ *
+ * Module graph extraction: the bundler groups modules per chunk, so
+ * the per-chunk module list is read directly. The
+ * `BuildDependencyGraph.entrypoints` shape is preserved so HMR
+ * invalidation and the build manifest keep working without changes.
+ */
+import type { BuildAdapter, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from './build-adapter.js';
+export declare class RolldownBuildAdapter implements BuildAdapter {
+    readonly ownership: "rolldown";
+    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;