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

package/src/build/build-adapter.js

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

@@ -1,33 +0,0 @@
-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[];