@ecopages/core 0.2.0-beta.3 → 0.2.0-beta.31

package/src/build/rolldown/rolldown-build-invocation-metrics.js

@@ -0,0 +1,43 @@
+const invocationCounts = /* @__PURE__ */ new Map();
+let pageModuleBuildInvocations = 0;
+function isRolldownBuildMetricsEnabled() {
+  return process.env.ECOPAGES_ROLLDOWN_BUILD_METRICS === "1" || process.env.ECOPAGES_LOGGER_DEBUG === "true";
+}
+function recordRolldownBuildInvocation(adapter = "rolldown") {
+  if (!isRolldownBuildMetricsEnabled()) {
+    return;
+  }
+  invocationCounts.set(adapter, (invocationCounts.get(adapter) ?? 0) + 1);
+}
+function getRolldownBuildInvocationCounts() {
+  return Object.fromEntries(invocationCounts);
+}
+function resetRolldownBuildInvocationCounts() {
+  invocationCounts.clear();
+  pageModuleBuildInvocations = 0;
+}
+function recordPageModuleBuildInvocation() {
+  if (!isRolldownBuildMetricsEnabled()) {
+    return;
+  }
+  pageModuleBuildInvocations += 1;
+}
+function getPageModuleRolldownBuildInvocations() {
+  return pageModuleBuildInvocations;
+}
+function getTotalRolldownBuildInvocations() {
+  let total = 0;
+  for (const count of invocationCounts.values()) {
+    total += count;
+  }
+  return total;
+}
+export {
+  getPageModuleRolldownBuildInvocations,
+  getRolldownBuildInvocationCounts,
+  getTotalRolldownBuildInvocations,
+  isRolldownBuildMetricsEnabled,
+  recordPageModuleBuildInvocation,
+  recordRolldownBuildInvocation,
+  resetRolldownBuildInvocationCounts
+};

package/src/build/{rolldown-plugin-bridge.d.ts → rolldown/rolldown-plugin-bridge.d.ts}

@@ -40,7 +40,8 @@
  * on every source file.
  */
 import type { Plugin } from 'rolldown';
-import type { EcoBuildPlugin } from './build-types.js';
+import type { EcoSourceTransform } from '../../plugins/source-transform.js';
+import type { EcoBuildPlugin } from '../contracts/build-types.js';
 /**
  * Creates a Rolldown `Plugin` array that drives the supplied
  * `EcoBuildPlugin` instances.
@@ -55,5 +56,18 @@ import type { EcoBuildPlugin } from './build-types.js';
  * Plugin ordering is preserved: registrations from earlier eco plugins
  * are checked before registrations from later ones, matching the
  * original per-plugin priority semantics.
+ *
+ * @remarks
+ * Rolldown re-fires `buildStart` on each build, so registrations and the
+ * virtual-module counter are cleared before every `setup` pass — otherwise
+ * handlers accumulate when bridge plugins are reused.
+ *
+ * @param plugins - `EcoBuildPlugin` instances registered for this build.
+ * @param contextRoot - Project root used to resolve relative load paths.
+ * @param sourceTransforms - Optional app-owned transforms applied after a matching
+ * `onLoad` handler returns module contents. Browser builds pass
+ * {@link getAppSourceTransforms | app source transforms} here so metadata injection
+ * still runs on output rewritten by boundary/runtime plugins. Virtual modules,
+ * CSS, and asset loads are skipped.
  */
-export declare function createRolldownPluginBridge(plugins: EcoBuildPlugin[], contextRoot: string): Plugin[];
+export declare function createRolldownPluginBridge(plugins: EcoBuildPlugin[], contextRoot: string, sourceTransforms?: readonly EcoSourceTransform[]): Plugin[];

package/src/build/{rolldown-plugin-bridge.js → rolldown/rolldown-plugin-bridge.js}

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { escapeRegExp } from "./browser-runtime-plugin-helpers.js";
+import { finalizeLoadResultWithSourceTransforms } from "./rolldown-source-transform-pass.js";
+import { escapeRegExp } from "../browser/browser-runtime-plugin-helpers.js";
 const NAMESPACE_SEPARATOR = ":";
 function joinNamespace(namespace, value) {
   return namespace ? `${namespace}${NAMESPACE_SEPARATOR}${value}` : value;
@@ -124,7 +125,7 @@ function convertPluginOnResolveResult(result, importer, contextRoot) {
   }
   return partial;
 }
-function createRolldownPluginBridge(plugins, contextRoot) {
+function createRolldownPluginBridge(plugins, contextRoot, sourceTransforms = []) {
   if (plugins.length === 0) {
     return [];
   }
@@ -152,22 +153,36 @@ function createRolldownPluginBridge(plugins, contextRoot) {
     return void 0;
   };
   const loadHandler = async (id) => {
+    let loadResult;
     for (const { filter, callback } of loadRegistrations) {
       if (!filter.test(id)) {
         continue;
       }
-      const { namespace, path: sourcePath } = splitNamespace(id);
-      const result = await callback({ path: sourcePath, namespace });
+      const { namespace: namespace2, path: sourcePath2 } = splitNamespace(id);
+      const result = await callback({ path: sourcePath2, namespace: namespace2 });
       const converted = convertPluginOnLoadResult({ id }, result);
       if (converted !== void 0) {
-        return converted;
+        loadResult = converted;
+        break;
       }
     }
-    return void 0;
+    const { namespace, path: sourcePath } = splitNamespace(id);
+    return finalizeLoadResultWithSourceTransforms({
+      id,
+      namespace,
+      sourcePath,
+      loadResult,
+      sourceTransforms,
+      contextRoot,
+      inferModuleTypeFromPath: (filePath) => inferRolldownModuleTypeFromPath(filePath)
+    });
   };
   const plugin = {
     name: "ecopages-plugin-bridge",
     buildStart: async () => {
+      resolveRegistrations.length = 0;
+      loadRegistrations.length = 0;
+      moduleCounter.value = 0;
       for (const ecoPlugin of plugins) {
         const bridge = {
           onResolve: (options, callback) => {

package/src/build/rolldown/rolldown-source-transform-pass.d.ts

@@ -0,0 +1,15 @@
+import type { LoadResult, SourceDescription } from 'rolldown';
+import { type EcoSourceTransform } from '../../plugins/source-transform.js';
+/**
+ * Runs app-owned source transforms after first-wins `onLoad` plugins produce
+ * module contents for one Rolldown load request.
+ */
+export declare function finalizeLoadResultWithSourceTransforms(options: {
+    id: string;
+    namespace: string | undefined;
+    sourcePath: string;
+    loadResult: LoadResult | undefined;
+    sourceTransforms: readonly EcoSourceTransform[];
+    contextRoot: string;
+    inferModuleTypeFromPath: (filePath: string) => SourceDescription['moduleType'];
+}): Promise<LoadResult | undefined>;

package/src/build/rolldown/rolldown-source-transform-pass.js

@@ -0,0 +1,61 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import {
+  applySourceTransforms,
+  normalizeTransformId
+} from "../../plugins/source-transform.js";
+const TRANSFORMABLE_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mdx"]);
+function shouldApplySourceTransforms(namespace, sourcePath) {
+  if (namespace !== void 0) {
+    return false;
+  }
+  const normalizedPath = normalizeTransformId(sourcePath);
+  return TRANSFORMABLE_SOURCE_EXTENSIONS.has(path.extname(normalizedPath).toLowerCase());
+}
+function shouldTransformLoadedModule(moduleType) {
+  return moduleType !== "css" && moduleType !== "asset";
+}
+function applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, code) {
+  if (sourceTransforms.length === 0) {
+    return code;
+  }
+  return applySourceTransforms(sourceTransforms, code, sourcePath);
+}
+async function finalizeLoadResultWithSourceTransforms(options) {
+  const { id, namespace, sourcePath, loadResult, sourceTransforms, contextRoot, inferModuleTypeFromPath } = options;
+  if (!shouldApplySourceTransforms(namespace, sourcePath)) {
+    return loadResult;
+  }
+  if (typeof loadResult === "object" && loadResult !== null && "code" in loadResult && typeof loadResult.code === "string") {
+    if (!shouldTransformLoadedModule(loadResult.moduleType)) {
+      return loadResult;
+    }
+    const transformedCode2 = applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, loadResult.code);
+    if (transformedCode2 === loadResult.code) {
+      return loadResult;
+    }
+    return {
+      code: transformedCode2,
+      moduleType: loadResult.moduleType
+    };
+  }
+  if (loadResult !== void 0 || sourceTransforms.length === 0) {
+    return loadResult;
+  }
+  const normalizedPath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(contextRoot, sourcePath);
+  if (!fileSystem.exists(normalizedPath)) {
+    return loadResult;
+  }
+  const originalCode = fileSystem.readFileSync(normalizedPath);
+  const transformedCode = applyTransformsToLoadedSource(sourceTransforms, id, sourcePath, originalCode);
+  if (transformedCode === originalCode) {
+    return loadResult;
+  }
+  return {
+    code: transformedCode,
+    moduleType: inferModuleTypeFromPath(normalizedPath)
+  };
+}
+export {
+  finalizeLoadResultWithSourceTransforms
+};

package/src/build/rolldown/runtime-build-output-normalizer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns true if the given specifier is a workspace package.
+ *
+ * Workspace packages are declared with the `workspace:` protocol and are
+ * typically source-only, requiring bundling rather than externalization.
+ */
+export declare function isWorkspacePackageImport(specifier: string, rootDir: string): boolean;
+export declare function isDeclaredAppPackageImport(specifier: string, rootDir: string): boolean;
+export declare function normalizeNodeRuntimeBuildOutputFile(filePath: string, rootDir: string): void;
+export declare function normalizeNodeRuntimeBuildOutputs(outputPaths: string[], rootDir: string): void;

package/src/build/rolldown/runtime-build-output-normalizer.js

@@ -0,0 +1,201 @@
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { isBarePackageImportSpecifier } from "../../plugins/tsconfig-import-resolver.js";
+const corePackageRequire = createRequire(new URL("../../../package.json", import.meta.url));
+const appDeclaredPackageCache = /* @__PURE__ */ new Map();
+const appWorkspacePackageCache = /* @__PURE__ */ new Map();
+const CORE_RUNTIME_BARE_SPECIFIER_PACKAGES = /* @__PURE__ */ new Set(["ws"]);
+function tryResolveRuntimeImport(specifier, resolver) {
+  try {
+    return resolver.resolve(specifier);
+  } catch {
+    return void 0;
+  }
+}
+function extractPackageNameFromFileUrl(specifier) {
+  if (!specifier.startsWith("file://")) {
+    return void 0;
+  }
+  const lastNodeModulesIndex = specifier.lastIndexOf("/node_modules/");
+  if (lastNodeModulesIndex === -1) {
+    return void 0;
+  }
+  const afterNodeModules = specifier.slice(lastNodeModulesIndex + "/node_modules/".length);
+  const parts = afterNodeModules.split("/");
+  if (parts.length === 0) {
+    return void 0;
+  }
+  if (parts[0]?.startsWith("@") && parts.length > 1) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
+}
+function getPackageNameFromSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    return specifier.split("/").slice(0, 2).join("/");
+  }
+  return specifier.split("/")[0] ?? specifier;
+}
+function getDeclaredAppPackages(rootDir) {
+  const cacheKey = path.resolve(rootDir);
+  const cached = appDeclaredPackageCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const packageJsonPath = path.resolve(rootDir, "package.json");
+  const declaredPackages = /* @__PURE__ */ new Set();
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const entries = packageJson[field];
+      if (!entries || typeof entries !== "object") {
+        continue;
+      }
+      for (const packageName of Object.keys(entries)) {
+        declaredPackages.add(packageName);
+      }
+    }
+  } catch {
+    appDeclaredPackageCache.set(cacheKey, declaredPackages);
+    return declaredPackages;
+  }
+  appDeclaredPackageCache.set(cacheKey, declaredPackages);
+  return declaredPackages;
+}
+function getWorkspacePackages(rootDir) {
+  const cacheKey = path.resolve(rootDir);
+  const cached = appWorkspacePackageCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const packageJsonPath = path.resolve(rootDir, "package.json");
+  const workspacePackages = /* @__PURE__ */ new Set();
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const entries = packageJson[field];
+      if (!entries || typeof entries !== "object") {
+        continue;
+      }
+      for (const [packageName, version] of Object.entries(entries)) {
+        if (typeof version === "string" && version.startsWith("workspace:")) {
+          workspacePackages.add(packageName);
+        }
+      }
+    }
+  } catch {
+    appWorkspacePackageCache.set(cacheKey, workspacePackages);
+    return workspacePackages;
+  }
+  appWorkspacePackageCache.set(cacheKey, workspacePackages);
+  return workspacePackages;
+}
+function isWorkspacePackageImport(specifier, rootDir) {
+  return getWorkspacePackages(rootDir).has(getPackageNameFromSpecifier(specifier));
+}
+function isDeclaredAppPackageImport(specifier, rootDir) {
+  return getDeclaredAppPackages(rootDir).has(getPackageNameFromSpecifier(specifier));
+}
+function isDeclaredInResolutionChain(specifier, rootDir) {
+  const packageName = getPackageNameFromSpecifier(specifier);
+  if (CORE_RUNTIME_BARE_SPECIFIER_PACKAGES.has(packageName)) {
+    return true;
+  }
+  return isDeclaredAppPackageImport(specifier, rootDir);
+}
+function rewriteRuntimeImportSpecifier(specifier, quote, rootDir) {
+  if (!isBarePackageImportSpecifier(specifier, rootDir)) {
+    return void 0;
+  }
+  if (isDeclaredInResolutionChain(specifier, rootDir)) {
+    return void 0;
+  }
+  const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
+  if (!resolvedPath || !/\.(?:[cm]?[jt]s|tsx|jsx)$/u.test(resolvedPath)) {
+    return void 0;
+  }
+  return `${quote}${pathToFileURL(resolvedPath).href}${quote}`;
+}
+function rewriteRuntimeBuildOutputImports(code, rootDir) {
+  const rewriteSpecifier = (prefix, quote, specifier) => {
+    const rewrittenSpecifier = rewriteRuntimeImportSpecifier(specifier, quote, rootDir);
+    return `${prefix}${rewrittenSpecifier ?? `${quote}${specifier}${quote}`}`;
+  };
+  const rewriteFileUrl = (prefix, quote, specifier) => {
+    const packageName = extractPackageNameFromFileUrl(specifier);
+    if (!packageName) {
+      return `${prefix}${quote}${specifier}${quote}`;
+    }
+    if (!isDeclaredInResolutionChain(packageName, rootDir)) {
+      return `${prefix}${quote}${specifier}${quote}`;
+    }
+    const lastNodeModulesIndex = specifier.lastIndexOf("/node_modules/");
+    if (lastNodeModulesIndex === -1) {
+      return `${prefix}${quote}${specifier}${quote}`;
+    }
+    const afterNodeModules = specifier.slice(lastNodeModulesIndex + "/node_modules/".length);
+    const afterPackage = afterNodeModules.slice(packageName.length);
+    const bareSpecifier = packageName + afterPackage;
+    return `${prefix}${quote}${bareSpecifier}${quote}`;
+  };
+  const withResolvedPackages = code.replace(
+    /(\bfrom\s+)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  ).replace(
+    /(\bimport\s+)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  ).replace(
+    /(\bimport\s*\(\s*)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  );
+  const withBareSpecifiers = withResolvedPackages.replace(
+    /(\bfrom\s+)(['"])(file:\/\/[^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteFileUrl(prefix, quote, specifier)
+  ).replace(
+    /(\bimport\s+)(['"])(file:\/\/[^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteFileUrl(prefix, quote, specifier)
+  ).replace(
+    /(\bimport\s*\(\s*)(['"])(file:\/\/[^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteFileUrl(prefix, quote, specifier)
+  );
+  return withBareSpecifiers.replace(
+    /(['"])(@oxc-project\/runtime\/(?:helpers(?:\/esm)?\/[^'"\\]+))\1/g,
+    (match, quote, specifier) => {
+      const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
+      return resolvedPath ? `${quote}${pathToFileURL(resolvedPath).href}${quote}` : match;
+    }
+  );
+}
+function normalizeNodeRuntimeBuildOutputFile(filePath, rootDir) {
+  if (process.env.ECOPAGES_LOGGER_DEBUG === "true") {
+    console.log(`[normalizeNodeRuntimeBuildOutputFile] Checking ${filePath}`);
+  }
+  if (!/\.(?:[cm]?js)$/u.test(filePath)) {
+    return;
+  }
+  const fileSystem = corePackageRequire("node:fs");
+  if (!fileSystem.existsSync(filePath)) {
+    return;
+  }
+  const code = fileSystem.readFileSync(filePath, "utf-8");
+  const rewritten = rewriteRuntimeBuildOutputImports(code, rootDir);
+  if (rewritten !== code) {
+    if (process.env.ECOPAGES_LOGGER_DEBUG === "true") {
+      console.log(`[normalizeNodeRuntimeBuildOutputFile] Rewriting ${filePath}`);
+    }
+    fileSystem.writeFileSync(filePath, rewritten);
+  }
+}
+function normalizeNodeRuntimeBuildOutputs(outputPaths, rootDir) {
+  for (const outputPath of outputPaths) {
+    normalizeNodeRuntimeBuildOutputFile(outputPath, rootDir);
+  }
+}
+export {
+  isDeclaredAppPackageImport,
+  isWorkspacePackageImport,
+  normalizeNodeRuntimeBuildOutputFile,
+  normalizeNodeRuntimeBuildOutputs
+};

package/src/build/runtime/build-profile-options.d.ts

@@ -0,0 +1,7 @@
+import type { BuildOptions } from '../build-adapter.js';
+import type { BuildProfile } from './build-runtime.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+/**
+ * Resolves shared Rolldown options for a build profile.
+ */
+export declare function resolveBuildProfileOptions(profile: BuildProfile, appConfig: EcoPagesAppConfig, overrides?: Partial<BuildOptions>): Partial<BuildOptions>;

package/src/build/runtime/build-profile-options.js

@@ -0,0 +1,37 @@
+function resolveBuildProfileOptions(profile, appConfig, overrides = {}) {
+  const root = appConfig.rootDir;
+  switch (profile) {
+    case "server-entry":
+      return {
+        root,
+        target: "node",
+        format: "esm",
+        sourcemap: "none",
+        minify: false,
+        externalPackages: true,
+        ...overrides
+      };
+    case "route-module":
+      return {
+        root,
+        target: "es2022",
+        format: "esm",
+        sourcemap: "none",
+        minify: false,
+        externalPackages: true,
+        ...overrides
+      };
+    case "browser-hmr":
+      return {
+        root,
+        target: "browser",
+        format: "esm",
+        sourcemap: "none",
+        minify: false,
+        ...overrides
+      };
+  }
+}
+export {
+  resolveBuildProfileOptions
+};

package/src/build/runtime/build-request-identity.d.ts

@@ -0,0 +1,17 @@
+import type { BuildOptions } from '../contracts/build-contracts.js';
+/**
+ * Canonical identity for one complete {@link BuildOptions} request.
+ *
+ * @remarks
+ * Semantically unordered collections (`external`, `define` keys, array entrypoints)
+ * are sorted. Plugin, `conditions`, and source-transform order is preserved because
+ * Rolldown hook and `conditionNames` precedence depend on it.
+ *
+ * Deprecated / ignored adapter fields (`splitting`, `bundle`, `outbase`) still
+ * participate in the key so requests that differ only on those fields do not
+ * coalesce. Empty `conditions` / `define` / `external` normalize to the same
+ * sentinel as `undefined`.
+ */
+export declare function createBuildRequestIdentity(options: BuildOptions): string;
+/** @deprecated Use {@link createBuildRequestIdentity}. */
+export declare const createBuildOptionsDedupeKey: typeof createBuildRequestIdentity;

package/src/build/runtime/build-request-identity.js

@@ -0,0 +1,54 @@
+import path from "node:path";
+import { createJsxCacheKey, createPluginCacheKey, createSourceTransformCacheKey } from "../cache/cache-keys.js";
+function normalizeEntrypoints(entrypoints) {
+  if (Array.isArray(entrypoints)) {
+    return entrypoints.map((entrypoint) => path.resolve(entrypoint)).sort().join("|");
+  }
+  return Object.entries(entrypoints).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}:${path.resolve(value)}`).join("|");
+}
+function normalizeOrderedStringList(values, label) {
+  if (!values || values.length === 0) {
+    return `${label}:default`;
+  }
+  return `${label}:${values.join(",")}`;
+}
+function normalizeUnorderedStringList(values, label) {
+  if (!values || values.length === 0) {
+    return `${label}:default`;
+  }
+  return `${label}:${[...values].sort().join(",")}`;
+}
+function normalizeDefine(define) {
+  if (!define || Object.keys(define).length === 0) {
+    return "define:default";
+  }
+  return `define:${Object.entries(define).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}=${value}`).join(",")}`;
+}
+function createBuildRequestIdentity(options) {
+  return [
+    normalizeEntrypoints(options.entrypoints),
+    options.root ? path.resolve(options.root) : "root:default",
+    options.outdir ? path.resolve(options.outdir) : "outdir:default",
+    options.outbase ? path.resolve(options.outbase) : "outbase:default",
+    options.splitting ?? "splitting:default",
+    options.bundle ?? "bundle:default",
+    options.externalPackages ?? "externalPackages:default",
+    options.target ?? "target:default",
+    options.format ?? "format:default",
+    options.sourcemap ?? "sourcemap:default",
+    options.minify ?? "minify:default",
+    options.treeshaking ?? "treeshaking:default",
+    options.naming ?? "naming:default",
+    normalizeOrderedStringList(options.conditions, "conditions"),
+    normalizeDefine(options.define),
+    normalizeUnorderedStringList(options.external, "external"),
+    createJsxCacheKey(options.jsx),
+    createPluginCacheKey(options.plugins),
+    createSourceTransformCacheKey(options.sourceTransforms)
+  ].join("::");
+}
+const createBuildOptionsDedupeKey = createBuildRequestIdentity;
+export {
+  createBuildOptionsDedupeKey,
+  createBuildRequestIdentity
+};

package/src/build/runtime/build-request-policy.d.ts

@@ -0,0 +1,59 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { EcoBuildPlugin } from '../contracts/build-types.js';
+import type { BuildOptions, BuildTranspileProfile } from '../contracts/build-contracts.js';
+import type { BuildProfile } from './build-runtime.js';
+/**
+ * Resolves app-owned server plugins plus JSX ownership for one config.
+ *
+ * @remarks
+ * Always goes through {@link getAppServerBuildPlugins} so sealed-manifest and
+ * loader-fallback apps share one plugin list with the alias resolver. Used by
+ * both request assembly and unified-graph cache keys.
+ */
+export declare function resolveServerAppBuildPlugins(appConfig: EcoPagesAppConfig): EcoBuildPlugin[];
+/**
+ * Merges caller plugins with app-owned manifest plugins.
+ *
+ * @remarks
+ * App-manifest plugins cannot be silently replaced by same-name caller plugins.
+ * Unique caller plugins are prepended so first-wins Rolldown hooks (for example
+ * React vendor/alias rewrites) still run before general app loaders. Use
+ * `excludeAppBuildPlugins` on browser requests to omit app-owned plugins.
+ */
+export declare function mergeCallerBuildPlugins(appPlugins: EcoBuildPlugin[], callerPlugins?: EcoBuildPlugin[]): EcoBuildPlugin[];
+export type ServerBuildRequestInput = Partial<BuildOptions> & {
+    entrypoints: BuildOptions['entrypoints'];
+    profile?: Extract<BuildProfile, 'server-entry' | 'route-module'>;
+};
+export type BrowserBuildRequestInput = Partial<BuildOptions> & {
+    entrypoints: BuildOptions['entrypoints'];
+    profile: BuildTranspileProfile;
+    excludeAppBuildPlugins?: string[];
+};
+/**
+ * Assembles a complete server-oriented {@link BuildOptions} before scheduling.
+ *
+ * @remarks
+ * Defaults `profile` to `'route-module'`. Plugins are
+ * {@link resolveServerAppBuildPlugins} plus unique caller contributions via
+ * {@link mergeCallerBuildPlugins}. Does not attach `sourceTransforms` — unlike
+ * {@link createBrowserBuildRequest}. Pass the returned options into
+ * {@link BuildRuntime.getProfile}; the runtime no longer injects plugins.
+ */
+export declare function createServerBuildRequest(appConfig: EcoPagesAppConfig, input: ServerBuildRequestInput): BuildOptions;
+/**
+ * Assembles a complete browser-oriented {@link BuildOptions} before scheduling.
+ *
+ * @remarks
+ * Applies {@link resolveBuildProfileOptions} for `'browser-hmr'` (browser target
+ * defaults), then overlays {@link getAppTranspileOptions} for the given
+ * {@link BuildTranspileProfile}. That profile selects transpile settings only;
+ * the {@link BuildRuntime} executor slot is chosen later by the caller
+ * (typically {@link BrowserBundleService}).
+ *
+ * Always attaches {@link getAppSourceTransforms}. App browser plugins come from
+ * {@link getAppBrowserBuildPlugins} (includes JSX ownership); use
+ * `excludeAppBuildPlugins` to omit app-owned names. Caller plugins cannot
+ * replace app-manifest names ({@link mergeCallerBuildPlugins}).
+ */
+export declare function createBrowserBuildRequest(appConfig: EcoPagesAppConfig, input: BrowserBuildRequestInput): BuildOptions;

package/src/build/runtime/build-request-policy.js

@@ -0,0 +1,46 @@
+import { getAppBrowserBuildPlugins, getAppServerBuildPlugins, getAppTranspileOptions } from "../build-adapter.js";
+import { resolveBuildProfileOptions } from "./build-profile-options.js";
+import { getJsxOwnershipPlugins } from "../browser/jsx-ownership-plugins.js";
+import { getAppSourceTransforms } from "../../plugins/source-transform.js";
+function resolveServerAppBuildPlugins(appConfig) {
+  return [...getAppServerBuildPlugins(appConfig), ...getJsxOwnershipPlugins(appConfig)];
+}
+function mergeCallerBuildPlugins(appPlugins, callerPlugins) {
+  if (!callerPlugins || callerPlugins.length === 0) {
+    return appPlugins;
+  }
+  const appByName = new Map(appPlugins.map((plugin) => [plugin.name, plugin]));
+  const uniqueCallerPlugins = callerPlugins.filter((plugin) => !appByName.has(plugin.name));
+  return [...uniqueCallerPlugins, ...appPlugins];
+}
+function createServerBuildRequest(appConfig, input) {
+  const profile = input.profile ?? "route-module";
+  const plugins = mergeCallerBuildPlugins(resolveServerAppBuildPlugins(appConfig), input.plugins);
+  const { plugins: _callerPlugins, profile: _profile, ...overrides } = input;
+  return {
+    ...resolveBuildProfileOptions(profile, appConfig, overrides),
+    ...overrides,
+    entrypoints: input.entrypoints,
+    ...plugins.length > 0 ? { plugins } : {}
+  };
+}
+function createBrowserBuildRequest(appConfig, input) {
+  const { profile, excludeAppBuildPlugins, plugins: callerPlugins, ...overrides } = input;
+  const appBrowserPlugins = getAppBrowserBuildPlugins(appConfig);
+  const filteredAppBrowserPlugins = excludeAppBuildPlugins && excludeAppBuildPlugins.length > 0 ? appBrowserPlugins.filter((plugin) => !excludeAppBuildPlugins.includes(plugin.name)) : appBrowserPlugins;
+  const plugins = mergeCallerBuildPlugins(filteredAppBrowserPlugins, callerPlugins);
+  return {
+    ...resolveBuildProfileOptions("browser-hmr", appConfig, overrides),
+    ...getAppTranspileOptions(appConfig, profile),
+    ...overrides,
+    entrypoints: input.entrypoints,
+    plugins,
+    sourceTransforms: getAppSourceTransforms(appConfig)
+  };
+}
+export {
+  createBrowserBuildRequest,
+  createServerBuildRequest,
+  mergeCallerBuildPlugins,
+  resolveServerAppBuildPlugins
+};