@ecopages/core 0.2.0-beta.4 → 0.2.0-beta.40

package/src/build/browser-runtime-plugin.js

@@ -1,173 +0,0 @@
-import path from "node:path";
-import { existsSync, readFileSync } from "node:fs";
-import { cachedParseSync } from "../cache/module-parse-cache.js";
-import { getBrowserRuntimeSpecifierMap } from "./browser-runtime-manifest.js";
-import { buildSpecifierFilter } from "./browser-runtime-plugin-helpers.js";
-const BROWSER_RUNTIME_IMPORT_REWRITE_MAP = /* @__PURE__ */ Symbol.for("ecopages.browserRuntimeImportRewriteMap");
-const DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME = "browser-runtime-plugin";
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object";
-}
-function inferLoaderFromPath(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  switch (extension) {
-    case ".mts":
-    case ".cts":
-    case ".ts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    default:
-      return "js";
-  }
-}
-function queueReplacement(options) {
-  if (!isRecord(options.source) || typeof options.source.value !== "string") {
-    return;
-  }
-  const mappedPath = options.specifierMap.get(options.source.value);
-  if (!mappedPath || typeof options.source.start !== "number" || typeof options.source.end !== "number") {
-    return;
-  }
-  const quote = options.code[options.source.start] === "'" ? "'" : '"';
-  options.edits.push({
-    start: options.source.start,
-    end: options.source.end,
-    replacement: `${quote}${mappedPath}${quote}`
-  });
-}
-function rewriteBrowserRuntimeImports(code, specifierMap, filePath = "browser-runtime-imports.js") {
-  if (specifierMap.size === 0) {
-    return code;
-  }
-  const edits = [];
-  try {
-    const result = cachedParseSync(filePath, code, {
-      sourceType: "module",
-      lang: path.extname(filePath).endsWith("x") ? "tsx" : "ts"
-    });
-    const walk = (node) => {
-      if (!isRecord(node)) {
-        return;
-      }
-      if (node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") {
-        queueReplacement({ code, source: node.source, specifierMap, edits });
-      }
-      if (node.type === "ImportExpression" && isRecord(node.source)) {
-        if (node.source.type === "StringLiteral" || node.source.type === "Literal") {
-          queueReplacement({ code, source: node.source, specifierMap, edits });
-        }
-      }
-      for (const value of Object.values(node)) {
-        if (Array.isArray(value)) {
-          for (const child of value) {
-            walk(child);
-          }
-        } else {
-          walk(value);
-        }
-      }
-    };
-    walk(result.program);
-  } catch {
-    return code;
-  }
-  if (edits.length === 0) {
-    return code;
-  }
-  edits.sort((left, right) => right.start - left.start);
-  let rewritten = code;
-  for (const edit of edits) {
-    rewritten = rewritten.slice(0, edit.start) + edit.replacement + rewritten.slice(edit.end);
-  }
-  return rewritten;
-}
-function getBrowserRuntimeImportRewriteMap(plugin) {
-  return plugin[BROWSER_RUNTIME_IMPORT_REWRITE_MAP];
-}
-function collectBrowserRuntimeImportRewriteMap(plugins) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const plugin of plugins ?? []) {
-    const specifierMap = getBrowserRuntimeImportRewriteMap(plugin);
-    if (!specifierMap) {
-      continue;
-    }
-    for (const [specifier, publicPath] of specifierMap.entries()) {
-      if (!merged.has(specifier)) {
-        merged.set(specifier, publicPath);
-      }
-    }
-  }
-  return merged;
-}
-function createBrowserRuntimePlugin(options) {
-  const { manifest } = options;
-  const specifierMap = getBrowserRuntimeSpecifierMap(manifest);
-  const specifierFilter = buildSpecifierFilter(specifierMap);
-  if (!specifierFilter) {
-    return null;
-  }
-  const external = options.external ?? true;
-  const rewriteImports = options.rewriteImports ?? true;
-  const matchPublicPaths = options.matchPublicPaths ?? true;
-  const publicPathSet = new Set(specifierMap.values());
-  const specifierKeys = Array.from(specifierMap.keys());
-  const plugin = {
-    name: options.name ?? DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME,
-    setup(build) {
-      build.onResolve({ filter: specifierFilter }, (args) => {
-        const mappedPath = specifierMap.get(args.path);
-        if (!mappedPath) {
-          return void 0;
-        }
-        return {
-          path: mappedPath,
-          external
-        };
-      });
-      if (matchPublicPaths) {
-        build.onResolve({ filter: /^\// }, (args) => {
-          if (!publicPathSet.has(args.path)) {
-            return void 0;
-          }
-          return {
-            path: args.path,
-            external: true
-          };
-        });
-      }
-      if (rewriteImports) {
-        build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
-          if (!path.isAbsolute(args.path) || !existsSync(args.path)) {
-            return void 0;
-          }
-          const code = readFileSync(args.path, "utf-8");
-          if (!specifierKeys.some((specifier) => code.includes(specifier))) {
-            return void 0;
-          }
-          const rewritten = rewriteBrowserRuntimeImports(code, specifierMap, args.path);
-          if (rewritten === code) {
-            return void 0;
-          }
-          return {
-            contents: rewritten,
-            loader: inferLoaderFromPath(args.path),
-            resolveDir: path.dirname(args.path)
-          };
-        });
-      }
-    }
-  };
-  plugin[BROWSER_RUNTIME_IMPORT_REWRITE_MAP] = specifierMap;
-  return plugin;
-}
-export {
-  BROWSER_RUNTIME_IMPORT_REWRITE_MAP,
-  DEFAULT_BROWSER_RUNTIME_PLUGIN_NAME,
-  collectBrowserRuntimeImportRewriteMap,
-  createBrowserRuntimePlugin,
-  getBrowserRuntimeImportRewriteMap,
-  rewriteBrowserRuntimeImports
-};

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[];

package/src/build/build-manifest.js

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

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

@@ -1,265 +0,0 @@
-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
-};

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

@@ -1,65 +0,0 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import { rolldown } from "rolldown";
-import {
-  buildResultFromRolldownOutput,
-  resolveRolldownOptions,
-  rewriteBrowserRuntimeImportsInOutputs,
-  rewriteNodeRuntimeImportsInOutputs,
-  toBuildLogs,
-  transpileProfileToOptions
-} from "./rolldown-adapter-helpers.js";
-const moduleRequire = createRequire(import.meta.url);
-class RolldownBuildAdapter {
-  ownership = "rolldown";
-  /** Per-adapter require cache, keyed on resolved context root. */
-  appRootRequireCache = /* @__PURE__ */ new Map();
-  /**
-   * Issues one build. Creates a fresh `rolldown()` bundler per call,
-   * so no module-graph reuse. For repeated rebuilds on the same
-   * entrypoints, use {@link RolldownDevBuildAdapter}.
-   */
-  async buildOrThrow(options) {
-    const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
-    const outdir = path.resolve(options.outdir ?? "dist/assets");
-    const plugins = options.plugins ?? [];
-    const { inputOptions, outputOptions } = resolveRolldownOptions(
-      options,
-      contextRoot,
-      outdir,
-      this.appRootRequireCache
-    );
-    const bundle = await rolldown(inputOptions);
-    const output = await bundle.write(outputOptions);
-    await bundle.close();
-    const baseResult = buildResultFromRolldownOutput(output, outdir, contextRoot);
-    return rewriteNodeRuntimeImportsInOutputs(
-      rewriteBrowserRuntimeImportsInOutputs(baseResult, contextRoot, plugins),
-      contextRoot
-    );
-  }
-  async build(options) {
-    try {
-      return await this.buildOrThrow(options);
-    } catch (error) {
-      return {
-        success: false,
-        logs: toBuildLogs(error),
-        outputs: []
-      };
-    }
-  }
-  resolve(importPath, rootDir) {
-    return moduleRequire.resolve(importPath, { paths: [rootDir] });
-  }
-  getTranspileOptions(profile) {
-    return transpileProfileToOptions(profile);
-  }
-}
-function createRolldownBuildAdapter() {
-  return new RolldownBuildAdapter();
-}
-export {
-  RolldownBuildAdapter,
-  createRolldownBuildAdapter
-};

package/src/build/rolldown-dev-build-adapter.d.ts

@@ -1,82 +0,0 @@
-/**
- * DevEngine-backed build adapter for cached incremental rebuilds.
- *
- * @remarks
- * Wraps Rolldown's experimental `DevEngine` to provide cached incremental
- * rebuilds. Unlike the standard `RolldownBuildAdapter` which creates a new
- * bundler for every build, this adapter keeps a `DevEngine` instance alive
- * and reuses the internal module graph, resolver cache, and transform cache
- * across builds.
- *
- * The adapter is designed for the HMR rebuild path where the same entrypoints
- * are rebuilt repeatedly with small changes. For one-off production builds,
- * use `RolldownBuildAdapter` instead.
- *
- * The first build creates the engine and runs it. Subsequent builds with the
- * same plugin/target/format triple reuse the cached engine and call
- * `triggerFullBuild()`. The cache key incorporates the context root, plugin
- * names, target, and format; when any of those change, the cached engine is
- * closed and a new one is created.
- *
- * Call `close()` to release the cached engine and free resources.
- *
- * @module
- */
-import type { BuildAdapter, BuildOptions, BuildResult, BuildTranspileOptions, BuildTranspileProfile } from './build-adapter.js';
-/**
- * Build adapter backed by Rolldown's DevEngine for cached incremental rebuilds.
- */
-export declare class RolldownDevBuildAdapter implements BuildAdapter {
-    /**
-     * `'rolldown-dev'` (not `'rolldown'`) so {@link getBuildAdapterOwnership}
-     * round-trips correctly and `createBuildAdapter({ ownership })` can
-     * re-select this class.
-     */
-    readonly ownership: "rolldown-dev";
-    private cachedEngine;
-    private engineInstanceCount;
-    private readonly pendingBuilds;
-    private readonly appRootRequireCache;
-    /**
-     * Stable key over the inputs that affect the engine configuration.
-     * Plugin order is intentionally not part of the key: two plugin
-     * sets with the same names are interchangeable for caching.
-     */
-    private getCacheKey;
-    /**
-     * Returns the cached engine, creating a new one when the cache
-     * key changes. On a cache miss the prior engine is closed and
-     * {@link engineInstanceCount} is incremented.
-     */
-    private getOrCreateEngine;
-    /**
-     * Triggers a build on the cached engine and returns the next
-     * `RolldownOutput` delivered to `onOutput`.
-     *
-     * First call after engine creation invokes `engine.run`; subsequent
-     * calls invoke `engine.triggerFullBuild` and reuse the cached
-     * module graph, resolver, and transform caches.
-     *
-     * If the trigger itself throws, the queued build is removed so
-     * the next `build()` does not consume a stale slot.
-     */
-    private runBuild;
-    /** Throws on error; see {@link build} for the no-throw variant. */
-    buildOrThrow(options: BuildOptions): Promise<BuildResult>;
-    build(options: BuildOptions): Promise<BuildResult>;
-    resolve(importPath: string, rootDir: string): string;
-    getTranspileOptions(profile: BuildTranspileProfile): BuildTranspileOptions;
-    /**
-     * Closes the cached DevEngine and rejects any in-flight builds
-     * with `'DevBuildAdapter closed'`.
-     *
-     * @remarks
-     * Not on the {@link BuildAdapter} interface, so it is only
-     * reachable through the concrete class. The adapter is meant to
-     * live for the process lifetime; this is for explicit teardown.
-     */
-    close(): Promise<void>;
-    /** Test-only: number of engines created over the adapter's lifetime. */
-    getEngineInstanceCountForTests(): number;
-}
-export declare function createRolldownDevBuildAdapter(): RolldownDevBuildAdapter;