@ecopages/core 0.2.0-alpha.8 → 0.2.1

package/src/build/build-adapter.js

@@ -4,11 +4,11 @@ import {
   getServerBuildPlugins
 } from "./build-manifest.js";
 import { EsbuildBuildAdapter } from "./esbuild-build-adapter.js";
-import { getRequiredBunRuntime } from "../utils/runtime.js";
+import { collectRuntimeSpecifierAliasMap, rewriteRuntimeSpecifierAliases } from "./runtime-specifier-aliases.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 createBuildAdapter() {
-  return new EsbuildBuildAdapter();
-}
 function transpileProfileToOptions(profile) {
   switch (profile) {
     case "browser-script":
@@ -32,32 +32,419 @@ function transpileProfileToOptions(profile) {
   }
 }
 class BunBuildAdapter {
-  async build(options) {
-    const bun = getRequiredBunRuntime();
-    const result = await bun.build({
-      ...options,
-      plugins: options.plugins
-    });
+  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);
+        }
+      }
+    };
+  }
+  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";
+    }
+    return options.format === "cjs" || options.format === "esm" ? ".js" : ".js";
+  }
+  resolveConcreteOutputPath(outputPath) {
+    if (fs.existsSync(outputPath)) {
+      return outputPath;
+    }
+    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]);
+  }
+  resolveTemplatedOutputPath(options, entrypointPath, concreteOutputPath) {
+    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(/^\.\//, "");
+    if (resolvedPath.includes("[hash]")) {
+      if (!concreteOutputPath) {
+        return path.join(outdir, resolvedPath);
+      }
+      const concreteRelativePath = path.relative(outdir, concreteOutputPath).split(path.sep).join("/");
+      const matcher = new RegExp(`^${this.escapeRegExp(resolvedPath).replace(/\\\[hash\\\]/g, "(.+)")}$`);
+      const match = concreteRelativePath.match(matcher);
+      if (!match?.[1]) {
+        return concreteOutputPath;
+      }
+      resolvedPath = resolvedPath.replaceAll("[hash]", match[1]);
+    }
+    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;
+  }
+  normalizeBunOutputs(result, options) {
+    if (!result.success || result.outputs.length === 0) {
+      return result;
+    }
+    const normalizedOutputs = [...result.outputs];
+    const canMapEntrypointsByIndex = options.entrypoints.length === normalizedOutputs.length;
+    if (canMapEntrypointsByIndex) {
+      for (const [index, entrypointPath] of options.entrypoints.entries()) {
+        const concreteOutputPath = this.resolveConcreteOutputPath(normalizedOutputs[index].path);
+        const expectedOutputPath = this.resolveTemplatedOutputPath(options, entrypointPath, concreteOutputPath);
+        if (!expectedOutputPath) {
+          continue;
+        }
+        normalizedOutputs[index] = {
+          path: this.relocateOutputFile(
+            concreteOutputPath ?? normalizedOutputs[index].path,
+            expectedOutputPath
+          )
+        };
+      }
+      return {
+        ...result,
+        outputs: normalizedOutputs
+      };
+    }
     return {
-      success: result.success,
-      logs: result.logs.map((log) => ({ message: log.message })),
-      outputs: result.outputs.map((output) => ({ path: output.path }))
+      ...result,
+      outputs: normalizedOutputs.map((output) => {
+        const concreteOutputPath = this.resolveConcreteOutputPath(output.path) ?? output.path;
+        if (path.extname(concreteOutputPath) !== "") {
+          return output;
+        }
+        const normalizedPath = `${concreteOutputPath}.js`;
+        return {
+          path: this.relocateOutputFile(concreteOutputPath, normalizedPath)
+        };
+      })
     };
   }
+  rewriteAliasedRuntimeSpecifiers(result, plugins) {
+    if (!result.success || result.outputs.length === 0) {
+      return result;
+    }
+    const aliasMap = collectRuntimeSpecifierAliasMap(plugins);
+    if (aliasMap.size === 0) {
+      return result;
+    }
+    for (const output of result.outputs) {
+      if (!/\.(?:[cm]?js)$/u.test(output.path) || !fs.existsSync(output.path)) {
+        continue;
+      }
+      const code = fs.readFileSync(output.path, "utf-8");
+      const rewritten = rewriteRuntimeSpecifierAliases(code, aliasMap);
+      if (rewritten !== code) {
+        fs.writeFileSync(output.path, rewritten);
+      }
+    }
+    return result;
+  }
+  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 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,
+        plugins: plugins.length > 0 ? [this.createEcoPluginBridge(plugins, contextRoot)] : void 0
+      });
+      return this.rewriteAliasedRuntimeSpecifiers(
+        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) {
-    return getRequiredBunRuntime().resolveSync(importPath, rootDir);
+    const bun = getBunRuntime();
+    if (!bun) {
+      return this.fallbackAdapter.resolve(importPath, rootDir);
+    }
+    return bun.resolveSync(importPath, rootDir);
   }
   getTranspileOptions(profile) {
     return transpileProfileToOptions(profile);
   }
 }
-const defaultBuildAdapter = createBuildAdapter();
+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 createBunBuildAdapter() {
+  return new BunBuildAdapter();
+}
+function createViteHostBuildAdapter() {
+  return new ViteHostBuildAdapter();
+}
+function createBuildAdapter(options) {
+  switch (options?.ownership ?? "bun-native") {
+    case "vite-host":
+      return createViteHostBuildAdapter();
+    case "bun-native":
+    default:
+      return createBunBuildAdapter();
+  }
+}
+const defaultBunBuildAdapter = createBuildAdapter({ ownership: "bun-native" });
+const defaultViteHostBuildAdapter = createBuildAdapter({ ownership: "vite-host" });
+const defaultBuildAdapter = defaultBunBuildAdapter;
+function getDefaultBuildAdapter(ownership = "bun-native") {
+  return ownership === "vite-host" ? defaultViteHostBuildAdapter : defaultBunBuildAdapter;
+}
+function getBuildAdapterOwnership(buildAdapter) {
+  return buildAdapter?.ownership ?? "bun-native";
+}
+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
   };
 }
@@ -97,7 +484,8 @@ 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 ?? []);
   }
   return {
     runtimePlugins,
@@ -140,29 +528,42 @@ function setAppBuildExecutor(appConfig, buildExecutor) {
     buildExecutor
   };
 }
-function build(options, executor = defaultBuildAdapter) {
+function build(options, executor = defaultBunBuildAdapter) {
   return executor.build(options);
 }
 function getTranspileOptions(profile) {
-  return defaultBuildAdapter.getTranspileOptions(profile);
+  return defaultBunBuildAdapter.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,
+  defaultViteHostBuildAdapter,
   getAppBrowserBuildPlugins,
   getAppBuildAdapter,
   getAppBuildExecutor,
   getAppBuildManifest,
+  getAppBuildOwnership,
   getAppServerBuildPlugins,
+  getAppTranspileOptions,
+  getBuildAdapterOwnership,
+  getDefaultBuildAdapter,
   getTranspileOptions,
   setAppBuildAdapter,
   setAppBuildExecutor,
   setAppBuildManifest,
+  setAppBuildOwnership,
   setupAppRuntimePlugins,
   updateAppBuildManifest
 };

package/src/build/dev-build-coordinator.d.ts

@@ -1,20 +1,20 @@
-import { type BuildAdapter, type BuildExecutor, type BuildOptions, type BuildResult, EsbuildBuildAdapter } from './build-adapter.js';
+import { type BuildAdapter, type BuildExecutor, type BuildOptions, type BuildResult } from './build-adapter.js';
+import { EsbuildBuildAdapter } from './esbuild-build-adapter.js';
 import type { EcoBuildPlugin } from './build-types.js';
 export declare function withBuildExecutorPlugins(executor: BuildExecutor, getPlugins: () => EcoBuildPlugin[]): BuildExecutor;
 /**
- * Serialized development build coordinator for the shared esbuild adapter.
+ * Serialized build coordinator for the shared esbuild adapter.
  *
  * The underlying adapter remains responsible for plain build execution. This
- * coordinator owns the policy that must be shared across callers in dev mode:
+ * coordinator owns the policy that must be shared across callers while Bun-native
+ * execution still uses the shared esbuild compatibility backend:
  *
  * - serialized access to the shared esbuild service
- * - warm-service recycling for Node-target builds
  * - recovery from known esbuild worker protocol faults
  *
  * Unlike the previous design, the coordinator does not monkey-patch the adapter
  * or install process-level fault handlers. The owning app/runtime passes this
- * executor explicitly to build consumers that need coordinated development
- * builds.
+ * executor explicitly to build consumers that need coordinated builds.
  */
 export declare class DevBuildCoordinator implements BuildExecutor {
     private buildQueue;
@@ -25,9 +25,6 @@ export declare class DevBuildCoordinator implements BuildExecutor {
     /**
      * Executes a build through the serialized development queue.
      *
-     * Node-target builds recycle the warmed esbuild service between requests to
-     * avoid stale worker state accumulating across long-lived dev sessions.
-     *
      * If an esbuild protocol fault is detected, the coordinator resets the queue,
      * stops the corrupted service, increments the module generation, and retries
      * the build once.
@@ -52,14 +49,15 @@ export declare class DevBuildCoordinator implements BuildExecutor {
      * Returns the current internal queue promise for fault-recovery tests.
      */
     getBuildQueueForTests(): Promise<void>;
-    private shouldRecycleEsbuildService;
     private runSerialized;
 }
 /**
  * Creates the appropriate build executor for one app/runtime instance.
  *
- * Development runtimes get a dedicated coordinator around the shared esbuild
- * adapter. Non-development runtimes use the adapter directly.
+ * Bun-native esbuild execution always uses the compatibility coordinator so
+ * preview/static generation and development flows share the same serialized
+ * access and protocol-fault recovery policy. Host-owned execution stays on the
+ * plain adapter boundary.
  */
 export declare function createAppBuildExecutor(options: {
     development: boolean;

package/src/build/dev-build-coordinator.js

@@ -1,9 +1,12 @@
 import { appLogger } from "../global/app-logger.js";
 import {
-  defaultBuildAdapter,
-  EsbuildBuildAdapter
+  defaultBunBuildAdapter
 } from "./build-adapter.js";
+import { EsbuildBuildAdapter, ESBUILD_ADAPTER_BRAND } from "./esbuild-build-adapter.js";
 import { mergeEcoBuildPlugins } from "./build-manifest.js";
+function isEsbuildBuildAdapter(adapter) {
+  return adapter instanceof EsbuildBuildAdapter || typeof adapter === "object" && adapter !== null && adapter[ESBUILD_ADAPTER_BRAND] === true;
+}
 function mergeBuildPlugins(options, appPlugins) {
   if (appPlugins.length === 0) {
     return options;
@@ -47,9 +50,6 @@ class DevBuildCoordinator {
   /**
    * Executes a build through the serialized development queue.
    *
-   * Node-target builds recycle the warmed esbuild service between requests to
-   * avoid stale worker state accumulating across long-lived dev sessions.
-   *
    * If an esbuild protocol fault is detected, the coordinator resets the queue,
    * stops the corrupted service, increments the module generation, and retries
    * the build once.
@@ -57,10 +57,6 @@ class DevBuildCoordinator {
   async build(options) {
     return this.runSerialized(async () => {
       try {
-        if (this.shouldRecycleEsbuildService(options)) {
-          await this.adapter.stopEsbuildService(this.esbuildModuleGeneration);
-          this.esbuildSessionWarm = false;
-        }
         const result = await this.adapter.buildOrThrow(options, this.esbuildModuleGeneration);
         this.esbuildSessionWarm = true;
         return result;
@@ -115,9 +111,6 @@ class DevBuildCoordinator {
   getBuildQueueForTests() {
     return this.buildQueue;
   }
-  shouldRecycleEsbuildService(options) {
-    return process.env.NODE_ENV === "development" && options.target !== "browser" && this.esbuildSessionWarm;
-  }
   async runSerialized(operation) {
     let releaseBuild;
     const currentBuild = new Promise((resolve) => {
@@ -134,15 +127,15 @@ class DevBuildCoordinator {
   }
 }
 function createAppBuildExecutor(options) {
-  const adapter = options.adapter ?? defaultBuildAdapter;
-  const baseExecutor = !options.development || !(adapter instanceof EsbuildBuildAdapter) ? adapter : new DevBuildCoordinator(adapter);
+  const adapter = options.adapter ?? defaultBunBuildAdapter;
+  const baseExecutor = isEsbuildBuildAdapter(adapter) ? new DevBuildCoordinator(adapter) : adapter;
   if (!options.getPlugins) {
     return baseExecutor;
   }
   return new BuildExecutorWithPlugins(baseExecutor, options.getPlugins);
 }
 function createOrReuseAppBuildExecutor(options) {
-  const adapter = options.adapter ?? defaultBuildAdapter;
+  const adapter = options.adapter ?? defaultBunBuildAdapter;
   const currentBaseExecutor = options.currentExecutor ? unwrapBuildExecutor(options.currentExecutor) : void 0;
   const baseExecutor = options.development && currentBaseExecutor instanceof DevBuildCoordinator ? currentBaseExecutor : createAppBuildExecutor({
     development: options.development,

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

@@ -5,7 +5,13 @@ import type { BuildAdapter, BuildOptions, BuildResult, BuildTranspileOptions, Bu
  * This adapter keeps Ecopages build plugin compatibility (`onResolve`, `onLoad`,
  * and `module`) while delegating bundling and TypeScript/decorator transforms to esbuild.
  */
+export declare const ESBUILD_ADAPTER_BRAND: unique symbol;
 export declare class EsbuildBuildAdapter implements BuildAdapter {
+    readonly ownership: "bun-native";
+    readonly [ESBUILD_ADAPTER_BRAND] = true;
+    private collectWorkspaceNodePaths;
+    private getFallbackNodePaths;
+    private rewriteAliasedRuntimeSpecifiers;
     private escapeRegExp;
     private getPluginsForBuild;
     private normalizeEsbuildLoader;