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

package/src/build/build-adapter.js

@@ -0,0 +1,240 @@
+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 { createRolldownBuildAdapter } from "./rolldown-build-adapter.js";
+function mergeBuildExecutorPlugins(existing, appPlugins) {
+  if (!existing || existing.length === 0) {
+    return appPlugins;
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const plugin of existing) {
+    byName.set(plugin.name, plugin);
+  }
+  for (const plugin of appPlugins) {
+    byName.set(plugin.name, plugin);
+  }
+  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 executor.build({
+        ...options,
+        plugins: mergeBuildExecutorPlugins(options.plugins, appPlugins)
+      });
+    }
+  };
+}
+function createHostOwnedBuildError(methodName) {
+  return new Error(
+    `Vite-hosted builds are owned by the host runtime. Core cannot ${methodName} through the host-owned compatibility adapter.`
+  );
+}
+class ViteHostBuildAdapter {
+  ownership = "vite-host";
+  async build(_options) {
+    throw createHostOwnedBuildError("build");
+  }
+  resolve(_importPath, _rootDir) {
+    throw createHostOwnedBuildError("resolve imports");
+  }
+  getTranspileOptions(_profile) {
+    throw createHostOwnedBuildError("derive transpile options");
+  }
+}
+function createViteHostBuildAdapter() {
+  return new ViteHostBuildAdapter();
+}
+function createBuildAdapter(options) {
+  switch (options?.ownership ?? "rolldown") {
+    case "vite-host":
+      return createViteHostBuildAdapter();
+    case "rolldown":
+    default:
+      return createRolldownBuildAdapter();
+  }
+}
+const defaultRolldownBuildAdapter = createBuildAdapter({ ownership: "rolldown" });
+const defaultViteHostBuildAdapter = createBuildAdapter({ ownership: "vite-host" });
+const defaultBuildAdapter = defaultRolldownBuildAdapter;
+function getDefaultBuildAdapter(ownership = "rolldown") {
+  return ownership === "vite-host" ? defaultViteHostBuildAdapter : defaultRolldownBuildAdapter;
+}
+function getBuildAdapterOwnership(buildAdapter) {
+  return buildAdapter?.ownership ?? "rolldown";
+}
+function getAppBuildOwnership(appConfig) {
+  return appConfig.runtime?.buildOwnership ?? getBuildAdapterOwnership(appConfig.runtime?.buildAdapter);
+}
+function setAppBuildOwnership(appConfig, buildOwnership) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    buildOwnership
+  };
+}
+function getAppBuildAdapter(appConfig) {
+  return appConfig.runtime?.buildAdapter ?? getDefaultBuildAdapter(getAppBuildOwnership(appConfig));
+}
+function setAppBuildAdapter(appConfig, buildAdapter) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    buildOwnership: getBuildAdapterOwnership(buildAdapter),
+    buildAdapter
+  };
+}
+function getAppBuildManifest(appConfig) {
+  return appConfig.runtime?.buildManifest ?? createAppBuildManifest({
+    loaderPlugins: Array.from(appConfig.loaders.values())
+  });
+}
+function setAppBuildManifest(appConfig, buildManifest) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    buildManifest
+  };
+}
+function createConfiguredAppBuildManifest(appConfig, input) {
+  return createAppBuildManifest({
+    loaderPlugins: input?.loaderPlugins ?? Array.from(appConfig.loaders.values()),
+    runtimePlugins: input?.runtimePlugins,
+    browserBundlePlugins: input?.browserBundlePlugins,
+    browserRuntimeManifest: input?.browserRuntimeManifest
+  });
+}
+function updateAppBuildManifest(appConfig, input) {
+  setAppBuildManifest(appConfig, createConfiguredAppBuildManifest(appConfig, input));
+}
+async function collectConfiguredAppBuildManifestContributions(appConfig) {
+  const runtimePlugins = [];
+  const browserBundlePlugins = [];
+  const browserRuntimeManifests = [];
+  for (const processor of appConfig.processors.values()) {
+    await processor.prepareBuildContributions();
+    if (processor.plugins) {
+      runtimePlugins.push(...processor.plugins);
+    }
+    if (processor.buildPlugins) {
+      browserBundlePlugins.push(...processor.buildPlugins);
+    }
+  }
+  for (const integration of appConfig.integrations) {
+    integration.setConfig(appConfig);
+    await integration.prepareBuildContributions();
+    runtimePlugins.push(...integration.plugins ?? []);
+    browserBundlePlugins.push(...integration.browserBuildPlugins ?? []);
+    browserRuntimeManifests.push(integration.browserRuntimeManifest);
+  }
+  return {
+    runtimePlugins,
+    browserBundlePlugins,
+    browserRuntimeManifest: mergeBrowserRuntimeManifests(...browserRuntimeManifests)
+  };
+}
+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) {
+        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);
+    }
+  }
+}
+function getAppServerBuildPlugins(appConfig) {
+  return getServerBuildPlugins(getAppBuildManifest(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, "-")}`
+    })
+  );
+}
+function getAppBuildExecutor(appConfig) {
+  return appConfig.runtime?.buildExecutor ?? getAppBuildAdapter(appConfig);
+}
+function setAppBuildExecutor(appConfig, buildExecutor) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    buildExecutor
+  };
+}
+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 defaultRolldownBuildAdapter.getTranspileOptions(profile);
+}
+function getAppTranspileOptions(appConfig, profile) {
+  return getAppBuildAdapter(appConfig).getTranspileOptions(profile);
+}
+export {
+  ViteHostBuildAdapter,
+  build,
+  collectConfiguredAppBuildManifestContributions,
+  createBuildAdapter,
+  createConfiguredAppBuildManifest,
+  createViteHostBuildAdapter,
+  defaultBuildAdapter,
+  defaultRolldownBuildAdapter,
+  defaultViteHostBuildAdapter,
+  getAppBrowserBuildPlugins,
+  getAppBuildAdapter,
+  getAppBuildExecutor,
+  getAppBuildManifest,
+  getAppBuildOwnership,
+  getAppServerBuildPlugins,
+  getAppTranspileOptions,
+  getBuildAdapterOwnership,
+  getDefaultBuildAdapter,
+  getTranspileOptions,
+  setAppBuildAdapter,
+  setAppBuildExecutor,
+  setAppBuildManifest,
+  setAppBuildOwnership,
+  setupAppRuntimePlugins,
+  updateAppBuildManifest,
+  withBuildExecutorPlugins
+};

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

@@ -0,0 +1,33 @@
+import type { EcoBuildPlugin } from './build-types.js';
+import { type BrowserRuntimeManifest } from './browser-runtime-manifest.js';
+export interface AppBuildManifest {
+    loaderPlugins: EcoBuildPlugin[];
+    runtimePlugins: EcoBuildPlugin[];
+    browserBundlePlugins: EcoBuildPlugin[];
+    browserRuntimeManifest: BrowserRuntimeManifest;
+}
+/**
+ * Merges plugin lists while preserving first-registration precedence by name.
+ *
+ * @remarks
+ * Build manifests treat plugin names as stable identities. The first plugin
+ * with a given name wins so config-time assembly stays deterministic across
+ * loader, runtime, and browser buckets.
+ */
+export declare function mergeEcoBuildPlugins(...pluginLists: Array<EcoBuildPlugin[] | undefined>): EcoBuildPlugin[];
+/**
+ * Creates one app-owned build manifest from the supplied plugin buckets.
+ */
+export declare function createAppBuildManifest(input?: Partial<AppBuildManifest>): AppBuildManifest;
+/**
+ * Returns the shared browser runtime asset manifest sealed into the app build manifest.
+ */
+export declare function getBrowserRuntimeManifest(manifest: AppBuildManifest): BrowserRuntimeManifest;
+/**
+ * Returns the plugin list used for server-oriented builds.
+ */
+export declare function getServerBuildPlugins(manifest: AppBuildManifest): EcoBuildPlugin[];
+/**
+ * Returns the plugin list used for browser-oriented builds.
+ */
+export declare function getBrowserBuildPlugins(manifest: AppBuildManifest): EcoBuildPlugin[];

package/src/build/build-manifest.js

@@ -0,0 +1,49 @@
+import { createBrowserRuntimePlugin, DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME } from "./browser-runtime-plugin.js";
+import {
+  createBrowserRuntimeManifest,
+  mergeBrowserRuntimeManifests
+} from "./browser-runtime-manifest.js";
+function mergeEcoBuildPlugins(...pluginLists) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const plugins of pluginLists) {
+    for (const plugin of plugins ?? []) {
+      if (!byName.has(plugin.name)) {
+        byName.set(plugin.name, plugin);
+      }
+    }
+  }
+  return Array.from(byName.values());
+}
+function createAppBuildManifest(input) {
+  return {
+    loaderPlugins: mergeEcoBuildPlugins(input?.loaderPlugins),
+    runtimePlugins: mergeEcoBuildPlugins(input?.runtimePlugins),
+    browserBundlePlugins: mergeEcoBuildPlugins(input?.browserBundlePlugins),
+    browserRuntimeManifest: mergeBrowserRuntimeManifests(input?.browserRuntimeManifest)
+  };
+}
+function getBrowserRuntimeManifest(manifest) {
+  return manifest.browserRuntimeManifest ?? createBrowserRuntimeManifest();
+}
+function getServerBuildPlugins(manifest) {
+  return mergeEcoBuildPlugins(manifest.loaderPlugins, manifest.runtimePlugins);
+}
+function getBrowserBuildPlugins(manifest) {
+  const runtimeRewritePlugin = createBrowserRuntimePlugin({
+    name: DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME,
+    manifest: getBrowserRuntimeManifest(manifest)
+  });
+  return mergeEcoBuildPlugins(
+    manifest.loaderPlugins,
+    manifest.runtimePlugins,
+    runtimeRewritePlugin ? [runtimeRewritePlugin] : [],
+    manifest.browserBundlePlugins
+  );
+}
+export {
+  createAppBuildManifest,
+  getBrowserBuildPlugins,
+  getBrowserRuntimeManifest,
+  getServerBuildPlugins,
+  mergeEcoBuildPlugins
+};

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

@@ -0,0 +1,57 @@
+/**
+ * Arguments passed to a build plugin `onResolve` callback.
+ */
+export type EcoBuildOnResolveArgs = {
+    path: string;
+    importer?: string;
+    namespace?: string;
+};
+/**
+ * Result returned by a build plugin `onResolve` callback.
+ */
+export type EcoBuildOnResolveResult = {
+    path?: string;
+    namespace?: string;
+    external?: boolean;
+};
+/**
+ * Arguments passed to a build plugin `onLoad` callback.
+ */
+export type EcoBuildOnLoadArgs = {
+    path: string;
+    namespace?: string;
+};
+/**
+ * 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';
+/**
+ * Result returned by a build plugin `onLoad` callback.
+ */
+export type EcoBuildOnLoadResult = {
+    contents?: string | Uint8Array;
+    loader?: EcoBuildLoader;
+    exports?: Record<string, unknown>;
+    resolveDir?: string;
+};
+/**
+ * Plugin builder contract consumed by build adapters.
+ */
+export interface EcoBuildPluginBuilder {
+    onResolve(options: {
+        filter: RegExp;
+        namespace?: string;
+    }, callback: (args: EcoBuildOnResolveArgs) => EcoBuildOnResolveResult | undefined | Promise<EcoBuildOnResolveResult | undefined>): void;
+    onLoad(options: {
+        filter: RegExp;
+        namespace?: string;
+    }, callback: (args: EcoBuildOnLoadArgs) => EcoBuildOnLoadResult | undefined | Promise<EcoBuildOnLoadResult | undefined>): void;
+    module(specifier: string, callback: () => EcoBuildOnLoadResult | Promise<EcoBuildOnLoadResult>): void;
+}
+/**
+ * Runtime-agnostic build plugin contract consumed by Ecopages processors/loaders.
+ */
+export type EcoBuildPlugin = {
+    name: string;
+    setup: (build: EcoBuildPluginBuilder) => void | Promise<void>;
+};

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;

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

@@ -0,0 +1,260 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { rolldown } from "rolldown";
+import { isDeclaredAppPackageImport, normalizeNodeRuntimeBuildOutputs } from "./runtime-build-output-normalizer.js";
+import { collectBrowserRuntimeImportRewriteMap, rewriteBrowserRuntimeImports } from "./browser-runtime-plugin.js";
+import { createRolldownPluginBridge } from "./rolldown-plugin-bridge.js";
+import { createServerSideCssShimPlugin } from "./server-side-css-shim-plugin.js";
+const moduleRequire = createRequire(import.meta.url);
+const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
+function tryResolveModule(id, resolver) {
+  try {
+    return resolver.resolve(id);
+  } catch {
+    return void 0;
+  }
+}
+function transpileProfileToOptions(profile) {
+  switch (profile) {
+    case "browser-script":
+    case "hmr-runtime":
+    case "hmr-entrypoint":
+      return {
+        target: "browser",
+        format: "esm",
+        sourcemap: "none"
+      };
+  }
+}
+function mapRolldownFormat(value) {
+  switch (value) {
+    case "cjs":
+      return "cjs";
+    case "iife":
+      return "iife";
+    case "esm":
+    default:
+      return "esm";
+  }
+}
+function mapRolldownPlatform(value) {
+  if (value === "browser") return "browser";
+  if (value === "node") return "node";
+  if (value && /^(?:es\d+|chrome\d+|edge\d+|firefox\d+|safari\d+|hermes|deno\d+|ios\d+)$/.test(value)) {
+    return "node";
+  }
+  return "neutral";
+}
+function mapRolldownSourcemap(value) {
+  switch (value) {
+    case "none":
+      return false;
+    case "inline":
+      return "inline";
+    case "external":
+    case "linked":
+      return "hidden";
+    default:
+      return true;
+  }
+}
+function mapRolldownJsx(jsx) {
+  const { factory, fragment, ...rest } = jsx;
+  const out = { ...rest };
+  if (factory !== void 0) {
+    out.pragma = factory;
+  }
+  if (fragment !== void 0) {
+    out.pragmaFrag = fragment;
+  }
+  return out;
+}
+function toEntryFileNamesPattern(value) {
+  if (!value) {
+    return void 0;
+  }
+  const literal = !/\[[^\]]+\]/u.test(value);
+  const stripped = value.replaceAll(/\.?\[ext\]/g, "");
+  if (stripped.length === 0) {
+    return void 0;
+  }
+  return { pattern: stripped, literal };
+}
+function getJavaScriptOutExtension(options, literal) {
+  if (literal) {
+    return void 0;
+  }
+  if (options.target === "browser") {
+    return ".js";
+  }
+  if (options.format === "cjs") {
+    return ".cjs";
+  }
+  return ".mjs";
+}
+function normalizeOutputPath(outputPath, outdir) {
+  return path.isAbsolute(outputPath) ? path.normalize(outputPath) : path.normalize(path.join(outdir, outputPath));
+}
+function normalizeModulePath(modulePath, contextRoot) {
+  return path.isAbsolute(modulePath) ? path.normalize(modulePath) : path.normalize(path.resolve(contextRoot, modulePath));
+}
+function extractDependencyGraph(chunks, contextRoot) {
+  const entrypoints = {};
+  for (const chunk of chunks) {
+    if (!chunk.facadeModuleId) {
+      continue;
+    }
+    const entrypointPath = normalizeModulePath(chunk.facadeModuleId, contextRoot);
+    entrypoints[entrypointPath] = Array.from(
+      /* @__PURE__ */ new Set([entrypointPath, ...chunk.moduleIds.map((id) => normalizeModulePath(id, contextRoot))])
+    );
+  }
+  return { entrypoints };
+}
+function toBuildLogs(error) {
+  if (error instanceof Error) {
+    return [{ message: error.message }];
+  }
+  return [{ message: "Unknown build error" }];
+}
+function isPackageImport(id) {
+  return !id.startsWith(".") && !path.isAbsolute(id) && !id.startsWith("/") && !id.startsWith("node:") && !id.startsWith("@/") && !id.startsWith("~/") && !id.startsWith("#") && !id.includes(":");
+}
+function shouldBundlePackageImport(id, contextRoot) {
+  if (isDeclaredAppPackageImport(id, contextRoot)) {
+    const appRootRequire = createRequire(path.join(contextRoot, "package.json"));
+    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));
+}
+function createExternalMatcher(options) {
+  const explicitExternals = new Set(options.external ?? []);
+  const externalPackages = options.externalPackages === true;
+  const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
+  return (id) => {
+    if (explicitExternals.has(id)) {
+      return true;
+    }
+    if (!externalPackages || !isPackageImport(id)) {
+      return false;
+    }
+    return !shouldBundlePackageImport(id, contextRoot);
+  };
+}
+function rewriteBrowserRuntimeImportsInOutputs(result, contextRoot, plugins) {
+  if (!result.success || result.outputs.length === 0) {
+    return result;
+  }
+  const specifierMap = collectBrowserRuntimeImportRewriteMap(plugins);
+  if (specifierMap.size === 0) {
+    return result;
+  }
+  const moduleRequireFromContext = createRequire(path.join(contextRoot, "package.json"));
+  for (const output of result.outputs) {
+    if (!/\.(?:[cm]?js)$/u.test(output.path)) {
+      continue;
+    }
+    const code = moduleRequireFromContext("node:fs").readFileSync(output.path, "utf-8");
+    const rewritten = rewriteBrowserRuntimeImports(code, specifierMap, output.path);
+    if (rewritten !== code) {
+      moduleRequireFromContext("node:fs").writeFileSync(output.path, rewritten);
+    }
+  }
+  return result;
+}
+function rewriteNodeRuntimeImportsInOutputs(result, contextRoot) {
+  if (!result.success || result.outputs.length === 0) {
+    return result;
+  }
+  normalizeNodeRuntimeBuildOutputs(
+    result.outputs.map((output) => output.path),
+    contextRoot
+  );
+  return result;
+}
+class RolldownBuildAdapter {
+  ownership = "rolldown";
+  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 external = createExternalMatcher(options);
+    const transformOptions = {};
+    if (options.define) {
+      transformOptions.define = options.define;
+    }
+    if (options.jsx) {
+      transformOptions.jsx = mapRolldownJsx(options.jsx);
+    }
+    if (options.target && /^(?:es|chrome|edge|firefox|safari|hermes|deno|ios)/.test(options.target)) {
+      transformOptions.target = options.target;
+    }
+    const bundle = await rolldown({
+      input: options.entrypoints,
+      cwd: contextRoot,
+      external,
+      platform: mapRolldownPlatform(options.target),
+      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,
+      plugins: [createServerSideCssShimPlugin(), ...createRolldownPluginBridge(plugins, contextRoot)]
+    });
+    const entryFileNames = toEntryFileNamesPattern(options.naming);
+    const jsExtension = getJavaScriptOutExtension(options, entryFileNames?.literal ?? false);
+    const finalEntryFileNames = entryFileNames ? jsExtension ? `${entryFileNames.pattern}${jsExtension}` : entryFileNames.pattern : jsExtension ? `[name]${jsExtension}` : "[name]";
+    const output = await bundle.write({
+      dir: outdir,
+      format: mapRolldownFormat(options.format),
+      minify: !!options.minify,
+      entryFileNames: finalEntryFileNames,
+      chunkFileNames: "[name]-[hash].js",
+      assetFileNames: "[name]-[hash][extname]",
+      sourcemap: mapRolldownSourcemap(options.sourcemap)
+    });
+    await bundle.close();
+    const outputs = output.output.map((entry) => ({ path: normalizeOutputPath(entry.fileName, outdir) }));
+    const entryChunks = output.output.filter(
+      (entry) => entry.type === "chunk" && entry.isEntry
+    );
+    const dependencyGraph = extractDependencyGraph(
+      entryChunks.map((chunk) => ({ facadeModuleId: chunk.facadeModuleId, moduleIds: chunk.moduleIds })),
+      contextRoot
+    );
+    const baseResult = {
+      success: true,
+      logs: [],
+      outputs,
+      dependencyGraph
+    };
+    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
+};