@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.41

package/src/build/build-adapter.js

@@ -1,5 +1,13 @@
+import {
+  createAppBuildManifest,
+  getBrowserBuildPlugins,
+  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 transpileProfileToOptions(profile) {
   switch (profile) {
@@ -24,31 +32,626 @@ 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 {
-      success: result.success,
-      logs: result.logs.map((log) => ({ message: log.message })),
-      outputs: result.outputs.map((output) => ({ path: output.path }))
+      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);
+        }
+      }
     };
   }
-  resolve(importPath, rootDir) {
-    return getRequiredBunRuntime().resolveSync(importPath, rootDir);
+  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";
+  }
+  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]);
   }
-  registerPlugin(plugin) {
-    getRequiredBunRuntime().plugin(plugin);
+  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}`);
+  }
+  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);
+  }
+  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 {
+      ...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)
+        };
+      })
+    };
+  }
+  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 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 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) {
+    const bun = getBunRuntime();
+    if (!bun) {
+      return this.fallbackAdapter.resolve(importPath, rootDir);
+    }
+    return bun.resolveSync(importPath, rootDir);
   }
   getTranspileOptions(profile) {
     return transpileProfileToOptions(profile);
   }
 }
-const defaultBuildAdapter = new EsbuildBuildAdapter();
+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 ?? 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
+  });
+}
+function updateAppBuildManifest(appConfig, input) {
+  setAppBuildManifest(appConfig, createConfiguredAppBuildManifest(appConfig, input));
+}
+async function collectConfiguredAppBuildManifestContributions(appConfig) {
+  const runtimePlugins = [];
+  const browserBundlePlugins = [];
+  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 ?? []);
+  }
+  return {
+    runtimePlugins,
+    browserBundlePlugins
+  };
+}
+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) {
+  return getBrowserBuildPlugins(getAppBuildManifest(appConfig));
+}
+function getAppBuildExecutor(appConfig) {
+  return appConfig.runtime?.buildExecutor ?? getAppBuildAdapter(appConfig);
+}
+function setAppBuildExecutor(appConfig, buildExecutor) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    buildExecutor
+  };
+}
+function build(options, executor = defaultBunBuildAdapter) {
+  return executor.build(options);
+}
+function getTranspileOptions(profile) {
+  return defaultBunBuildAdapter.getTranspileOptions(profile);
+}
+function getAppTranspileOptions(appConfig, profile) {
+  return getAppBuildAdapter(appConfig).getTranspileOptions(profile);
+}
 export {
   BunBuildAdapter,
   EsbuildBuildAdapter2 as EsbuildBuildAdapter,
-  defaultBuildAdapter
+  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/build-manifest.d.ts

@@ -0,0 +1,27 @@
+import type { EcoBuildPlugin } from './build-types.js';
+export interface AppBuildManifest {
+    loaderPlugins: EcoBuildPlugin[];
+    runtimePlugins: EcoBuildPlugin[];
+    browserBundlePlugins: EcoBuildPlugin[];
+}
+/**
+ * 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 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[];