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

package/src/build/build-adapter.js

@@ -1,63 +1,96 @@
+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 { EsbuildBuildAdapter } from "./esbuild-build-adapter.js";
-import { getRequiredBunRuntime } from "../utils/runtime.js";
-import { EsbuildBuildAdapter as EsbuildBuildAdapter2 } from "./esbuild-build-adapter.js";
-function createBuildAdapter() {
-  return new EsbuildBuildAdapter();
-}
-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"
-      };
+import { createRolldownBuildAdapter } from "./rolldown-build-adapter.js";
+import { createRolldownDevBuildAdapter } from "./rolldown-dev-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());
 }
-class BunBuildAdapter {
-  async build(options) {
-    const bun = getRequiredBunRuntime();
-    const result = await bun.build({
-      ...options,
-      plugins: options.plugins
-    });
-    return {
-      success: result.success,
-      logs: result.logs.map((log) => ({ message: log.message })),
-      outputs: result.outputs.map((output) => ({ path: output.path }))
-    };
+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) {
-    return getRequiredBunRuntime().resolveSync(importPath, rootDir);
+  resolve(_importPath, _rootDir) {
+    throw createHostOwnedBuildError("resolve imports");
   }
-  getTranspileOptions(profile) {
-    return transpileProfileToOptions(profile);
+  getTranspileOptions(_profile) {
+    throw createHostOwnedBuildError("derive transpile options");
   }
 }
-const defaultBuildAdapter = createBuildAdapter();
+function createViteHostBuildAdapter() {
+  return new ViteHostBuildAdapter();
+}
+function createBuildAdapter(options) {
+  switch (options?.ownership ?? "rolldown") {
+    case "vite-host":
+      return createViteHostBuildAdapter();
+    case "rolldown-dev":
+      return createRolldownDevBuildAdapter();
+    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 ?? defaultBuildAdapter;
+  return appConfig.runtime?.buildAdapter ?? getDefaultBuildAdapter(getAppBuildOwnership(appConfig));
 }
 function setAppBuildAdapter(appConfig, buildAdapter) {
   appConfig.runtime = {
     ...appConfig.runtime ?? {},
+    buildOwnership: getBuildAdapterOwnership(buildAdapter),
     buildAdapter
   };
 }
@@ -76,7 +109,8 @@ function createConfiguredAppBuildManifest(appConfig, input) {
   return createAppBuildManifest({
     loaderPlugins: input?.loaderPlugins ?? Array.from(appConfig.loaders.values()),
     runtimePlugins: input?.runtimePlugins,
-    browserBundlePlugins: input?.browserBundlePlugins
+    browserBundlePlugins: input?.browserBundlePlugins,
+    browserRuntimeManifest: input?.browserRuntimeManifest
   });
 }
 function updateAppBuildManifest(appConfig, input) {
@@ -85,6 +119,7 @@ function updateAppBuildManifest(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) {
@@ -97,14 +132,20 @@ async function collectConfiguredAppBuildManifestContributions(appConfig) {
   for (const integration of appConfig.integrations) {
     integration.setConfig(appConfig);
     await integration.prepareBuildContributions();
-    runtimePlugins.push(...integration.plugins);
+    runtimePlugins.push(...integration.plugins ?? []);
+    browserBundlePlugins.push(...integration.browserBuildPlugins ?? []);
+    browserRuntimeManifests.push(integration.browserRuntimeManifest);
   }
   return {
     runtimePlugins,
-    browserBundlePlugins
+    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) {
@@ -129,7 +170,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);
@@ -140,29 +196,48 @@ function setAppBuildExecutor(appConfig, buildExecutor) {
     buildExecutor
   };
 }
-function build(options, executor = defaultBuildAdapter) {
-  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 defaultBuildAdapter.getTranspileOptions(profile);
+  return defaultRolldownBuildAdapter.getTranspileOptions(profile);
+}
+function getAppTranspileOptions(appConfig, profile) {
+  return getAppBuildAdapter(appConfig).getTranspileOptions(profile);
 }
 export {
-  BunBuildAdapter,
-  EsbuildBuildAdapter2 as EsbuildBuildAdapter,
+  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
+  updateAppBuildManifest,
+  withBuildExecutorPlugins
 };

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

@@ -1,8 +1,10 @@
 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.
@@ -17,6 +19,10 @@ export declare function mergeEcoBuildPlugins(...pluginLists: Array<EcoBuildPlugi
  * 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.
  */

package/src/build/build-manifest.js

@@ -1,3 +1,8 @@
+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) {
@@ -13,18 +18,32 @@ function createAppBuildManifest(input) {
   return {
     loaderPlugins: mergeEcoBuildPlugins(input?.loaderPlugins),
     runtimePlugins: mergeEcoBuildPlugins(input?.runtimePlugins),
-    browserBundlePlugins: mergeEcoBuildPlugins(input?.browserBundlePlugins)
+    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) {
-  return mergeEcoBuildPlugins(manifest.loaderPlugins, manifest.runtimePlugins, manifest.browserBundlePlugins);
+  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

@@ -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-adapter-helpers.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared helpers for the Rolldown-backed build adapters.
+ *
+ * @remarks
+ * The standard {@link RolldownBuildAdapter} (one-shot production builds)
+ * and the dev {@link RolldownDevBuildAdapter} (DevEngine-backed
+ * incremental rebuilds) both need the same BuildOptions → Rolldown
+ * mapping, the same dependency-graph extraction, and the same
+ * post-build rewriting pipeline. This module hosts the shared code so
+ * the two adapters stay semantically identical.
+ *
+ * @module
+ */
+import type { InputOptions, OutputOptions } from 'rolldown';
+import type { EcoBuildPlugin } from './build-types.js';
+import type { BuildDependencyGraph, BuildLog, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from './build-adapter.js';
+export declare function transpileProfileToOptions(profile: BuildTranspileProfile): BuildTranspileOptions;
+export declare function extractDependencyGraph(chunks: Array<{
+    facadeModuleId: string | null;
+    moduleIds: string[];
+}>, contextRoot: string): BuildDependencyGraph;
+export declare function toBuildLogs(error: unknown): BuildLog[];
+/** Translated Rolldown options for one {@link BuildOptions} request. */
+export interface ResolvedRolldownOptions {
+    inputOptions: InputOptions;
+    outputOptions: OutputOptions;
+}
+/**
+ * Translates a {@link BuildOptions} into Rolldown's `InputOptions` and
+ * `OutputOptions`. Always sets `experimental.nativeMagicString: true`
+ * and always consolidates eco plugins via the bridge.
+ */
+export declare function resolveRolldownOptions(options: BuildOptions, contextRoot: string, outdir: string, appRootRequireCache: Map<string, NodeJS.Require>): ResolvedRolldownOptions;
+/**
+ * Rewrites manifest-owned runtime specifiers in emitted JS output
+ * files. Skips work when the specifier map is empty or when a
+ * `(specifierMap, path, content)` tuple was already seen.
+ *
+ * The content cache is module-level and is keyed on a djb2 hash of
+ * the input bytes plus a sorted fingerprint of the specifier map. A
+ * manifest change correctly invalidates prior entries; different
+ * content of the same length does not collide.
+ */
+export declare function rewriteBrowserRuntimeImportsInOutputs(result: BuildResult, contextRoot: string, plugins: EcoBuildPlugin[]): BuildResult;
+/** Test-only: clears the rewriter content cache. */
+export declare function clearRewriteCacheForTests(): void;
+/** Normalizes node-runtime import paths in emitted outputs. */
+export declare function rewriteNodeRuntimeImportsInOutputs(result: BuildResult, contextRoot: string): BuildResult;
+/** Maps a Rolldown `output` to a normalized {@link BuildResult}. */
+export declare function buildResultFromRolldownOutput(output: {
+    output: Array<{
+        fileName: string;
+        type?: string;
+        isEntry?: boolean;
+        facadeModuleId?: string | null;
+        moduleIds?: string[];
+    }>;
+}, outdir: string, contextRoot: string): BuildResult;

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

@@ -0,0 +1,265 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { collectBrowserRuntimeImportRewriteMap, rewriteBrowserRuntimeImports } from "./browser-runtime-plugin.js";
+import { createServerSideCssShimPlugin } from "./server-side-css-shim-plugin.js";
+import { createRolldownPluginBridge } from "./rolldown-plugin-bridge.js";
+import { isDeclaredAppPackageImport, normalizeNodeRuntimeBuildOutputs } from "./runtime-build-output-normalizer.js";
+const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
+function transpileProfileToOptions(profile) {
+  switch (profile) {
+    case "browser-script":
+    case "hmr-runtime":
+    case "hmr-entrypoint":
+      return {
+        target: "browser",
+        format: "esm",
+        sourcemap: "none"
+      };
+  }
+}
+function isPackageImport(id) {
+  return !id.startsWith(".") && !path.isAbsolute(id) && !id.startsWith("/") && !id.startsWith("node:") && !id.startsWith("@/") && !id.startsWith("~/") && !id.startsWith("#") && !id.includes(":");
+}
+function tryResolveModule(id, resolver) {
+  try {
+    return resolver.resolve(id);
+  } catch {
+    return void 0;
+  }
+}
+function getAppRootRequire(cache, contextRoot) {
+  const cacheKey = path.resolve(contextRoot);
+  let req = cache.get(cacheKey);
+  if (!req) {
+    req = createRequire(path.join(cacheKey, "package.json"));
+    cache.set(cacheKey, req);
+  }
+  return req;
+}
+function shouldBundlePackageImport(id, contextRoot, appRootRequireCache) {
+  if (isDeclaredAppPackageImport(id, contextRoot)) {
+    const appRootRequire = getAppRootRequire(appRootRequireCache, contextRoot);
+    const appResolvedPath = tryResolveModule(id, appRootRequire);
+    return Boolean(appResolvedPath && /\.(?:[cm]?ts|tsx|jsx)$/u.test(appResolvedPath));
+  }
+  const coreResolvedPath = tryResolveModule(id, corePackageRequire);
+  return Boolean(coreResolvedPath && /\.(?:[cm]?ts|tsx|jsx)$/u.test(coreResolvedPath));
+}
+function createExternalMatcher(options, appRootRequireCache) {
+  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, appRootRequireCache);
+  };
+}
+function mapRolldownFormat(value) {
+  switch (value) {
+    case "cjs":
+      return "cjs";
+    case "iife":
+      return "iife";
+    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 resolveRolldownOptions(options, contextRoot, outdir, appRootRequireCache) {
+  const external = createExternalMatcher(options, appRootRequireCache);
+  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 bundlePlugins = options.plugins ?? [];
+  const appPlugins = createRolldownPluginBridge(bundlePlugins, contextRoot);
+  const allPlugins = [...options.target !== "browser" ? [createServerSideCssShimPlugin()] : [], ...appPlugins];
+  const inputOptions = {
+    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,
+    experimental: {
+      nativeMagicString: true
+    },
+    plugins: allPlugins
+  };
+  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 outputOptions = {
+    dir: outdir,
+    format: mapRolldownFormat(options.format),
+    minify: !!options.minify,
+    entryFileNames: finalEntryFileNames,
+    chunkFileNames: "[name]-[hash].js",
+    assetFileNames: "[name]-[hash][extname]",
+    sourcemap: mapRolldownSourcemap(options.sourcemap)
+  };
+  return { inputOptions, outputOptions };
+}
+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"));
+  const fs = moduleRequireFromContext("node:fs");
+  const cacheFingerprint = `${Array.from(specifierMap.entries()).sort().join("|")}`;
+  for (const output of result.outputs) {
+    if (!/\.(?:[cm]?js)$/u.test(output.path)) {
+      continue;
+    }
+    const code = fs.readFileSync(output.path, "utf-8");
+    const contentKey = `${cacheFingerprint}::${output.path}::${djb2(code)}`;
+    if (rewriteCache.has(contentKey)) {
+      continue;
+    }
+    const rewritten = rewriteBrowserRuntimeImports(code, specifierMap, output.path);
+    if (rewritten !== code) {
+      fs.writeFileSync(output.path, rewritten);
+    }
+    rewriteCache.add(contentKey);
+  }
+  return result;
+}
+const rewriteCache = /* @__PURE__ */ new Set();
+function djb2(input) {
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash + input.charCodeAt(i) | 0;
+  }
+  return hash.toString(36);
+}
+function clearRewriteCacheForTests() {
+  rewriteCache.clear();
+}
+function rewriteNodeRuntimeImportsInOutputs(result, contextRoot) {
+  if (!result.success || result.outputs.length === 0) {
+    return result;
+  }
+  normalizeNodeRuntimeBuildOutputs(
+    result.outputs.map((output) => output.path),
+    contextRoot
+  );
+  return result;
+}
+function buildResultFromRolldownOutput(output, outdir, contextRoot) {
+  const outputs = output.output.map((entry) => ({
+    path: normalizeOutputPath(entry.fileName, outdir)
+  }));
+  const entryChunks = output.output.filter((entry) => entry.type === "chunk" && entry.isEntry);
+  const dependencyGraph = entryChunks.length > 0 ? extractDependencyGraph(entryChunks, contextRoot) : void 0;
+  return {
+    success: true,
+    logs: [],
+    outputs,
+    dependencyGraph
+  };
+}
+export {
+  buildResultFromRolldownOutput,
+  clearRewriteCacheForTests,
+  extractDependencyGraph,
+  resolveRolldownOptions,
+  rewriteBrowserRuntimeImportsInOutputs,
+  rewriteNodeRuntimeImportsInOutputs,
+  toBuildLogs,
+  transpileProfileToOptions
+};