@ecopages/core 0.2.0-beta.2 → 0.2.0-beta.20

package/src/adapters/shared/shared-hmr-manager.js

@@ -2,11 +2,14 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { RESOLVED_ASSETS_DIR } from "../../config/constants.js";
-import { getAppBuildExecutor } from "../../build/build-adapter.js";
+import { resolveHmrEntrypointOutputPaths } from "../../hmr/hmr-entrypoint-output.js";
+import { requireBuildRuntime } from "../../build/build-runtime.js";
 import { fileSystem } from "@ecopages/file-system";
 import { HmrStrategyType } from "../../hmr/hmr-strategy.js";
 import { DefaultHmrStrategy } from "../../hmr/strategies/default-hmr-strategy.js";
 import { JsHmrStrategy } from "../../hmr/strategies/js-hmr-strategy.js";
+import { ServerRenderedTemplateHmrStrategy } from "../../hmr/strategies/server-rendered-template-hmr-strategy.js";
+import { DevelopmentInvalidationService } from "../../services/invalidation/development-invalidation.service.js";
 import { appLogger } from "../../global/app-logger.js";
 import { HmrEntrypointRegistrar } from "./hmr-entrypoint-registrar.js";
 import { BrowserBundleService } from "../../services/assets/browser-bundle.service.js";
@@ -16,6 +19,24 @@ import {
   setAppEntrypointDependencyGraph
 } from "../../services/runtime-state/entrypoint-dependency-graph.service.js";
 import { resolveInternalExecutionDir, resolveInternalWorkDir } from "../../utils/resolve-work-dir.js";
+const DEFAULT_HMR_REGISTRATION_TIMEOUT_MS = 4e3;
+const DEVELOPMENT_HMR_REGISTRATION_TIMEOUT_MS = 15e3;
+function resolveHmrRegistrationTimeoutMs(explicitTimeoutMs) {
+  if (explicitTimeoutMs !== void 0) {
+    return explicitTimeoutMs;
+  }
+  const envTimeoutMs = process.env.ECOPAGES_HMR_REGISTRATION_TIMEOUT_MS;
+  if (envTimeoutMs !== void 0 && envTimeoutMs !== "") {
+    const parsedTimeoutMs = Number(envTimeoutMs);
+    if (Number.isFinite(parsedTimeoutMs) && parsedTimeoutMs > 0) {
+      return parsedTimeoutMs;
+    }
+  }
+  if (process.env.NODE_ENV === "development") {
+    return DEVELOPMENT_HMR_REGISTRATION_TIMEOUT_MS;
+  }
+  return DEFAULT_HMR_REGISTRATION_TIMEOUT_MS;
+}
 class SharedHmrManager {
   appConfig;
   bridge;
@@ -24,13 +45,14 @@ class SharedHmrManager {
   entrypointRegistrations = /* @__PURE__ */ new Map();
   distDir;
   plugins = [];
-  enabled = true;
+  enabled = false;
   strategies = [];
   entrypointRegistrar;
   browserBundleService;
   entrypointDependencyGraph;
   serverModuleTranspiler;
-  constructor({ appConfig, bridge, registrationTimeoutMs = 4e3 }) {
+  runtimeBuildPromise = null;
+  constructor({ appConfig, bridge, registrationTimeoutMs }) {
     this.appConfig = appConfig;
     this.bridge = bridge;
     this.distDir = path.join(resolveInternalWorkDir(this.appConfig), RESOLVED_ASSETS_DIR, "_hmr");
@@ -40,7 +62,7 @@ class SharedHmrManager {
       entrypointRegistrations: this.entrypointRegistrations,
       watchedFiles: this.watchedFiles,
       clearFailedRegistration: (entrypointPath) => this.clearFailedEntrypointRegistration(entrypointPath),
-      registrationTimeoutMs
+      registrationTimeoutMs: resolveHmrRegistrationTimeoutMs(registrationTimeoutMs)
     });
     this.browserBundleService = new BrowserBundleService(appConfig);
     this.entrypointDependencyGraph = this.createEntrypointDependencyGraph(
@@ -86,7 +108,12 @@ class SharedHmrManager {
       getEntrypointDependencyGraph: () => this.entrypointDependencyGraph,
       shouldProcessEntrypoint: (entrypointPath) => this.shouldJsStrategyProcessEntrypoint(entrypointPath)
     };
-    this.strategies = [new JsHmrStrategy(jsContext), new DefaultHmrStrategy()];
+    const invalidationService = new DevelopmentInvalidationService(this.appConfig);
+    this.strategies = [
+      new JsHmrStrategy(jsContext),
+      new ServerRenderedTemplateHmrStrategy(invalidationService),
+      new DefaultHmrStrategy()
+    ];
   }
   registerStrategy(strategy) {
     this.strategies.push(strategy);
@@ -100,7 +127,33 @@ class SharedHmrManager {
   isEnabled() {
     return this.enabled;
   }
+  isRuntimeReady() {
+    return fileSystem.exists(this.getRuntimePath());
+  }
+  /**
+   * Builds the browser HMR runtime once and reuses the in-flight build for concurrent callers.
+   */
+  async ensureRuntimeReady() {
+    if (this.isRuntimeReady()) {
+      return true;
+    }
+    if (this.runtimeBuildPromise) {
+      return this.runtimeBuildPromise;
+    }
+    this.runtimeBuildPromise = this.buildRuntimeInternal();
+    try {
+      return await this.runtimeBuildPromise;
+    } finally {
+      this.runtimeBuildPromise = null;
+    }
+  }
   async buildRuntime() {
+    await this.ensureRuntimeReady();
+  }
+  getRuntimePath() {
+    return path.join(this.distDir, "_hmr_runtime.js");
+  }
+  async buildRuntimeInternal() {
     const runtimeSource = fileURLToPath(import.meta.resolve("@ecopages/core/hmr/client/hmr-runtime"));
     try {
       const result = await this.browserBundleService.bundle({
@@ -113,13 +166,32 @@ class SharedHmrManager {
       });
       if (!result.success) {
         this.onRuntimeBundleFailure(result.logs);
+        return false;
       }
+      this.syncRuntimeOutput(result);
+      return this.isRuntimeReady();
     } catch (error) {
       this.onRuntimeBundleFailure(error);
+      return false;
     }
   }
-  getRuntimePath() {
-    return path.join(this.distDir, "_hmr_runtime.js");
+  /**
+   * @remarks
+   * Rolldown may emit the runtime bundle under a derived filename when the
+   * entrypoint lives outside the app root. The dev server always serves
+   * `/_hmr_runtime.js` from a stable path under `.eco/assets/_hmr/`.
+   */
+  syncRuntimeOutput(result) {
+    const runtimePath = this.getRuntimePath();
+    if (fileSystem.exists(runtimePath)) {
+      return;
+    }
+    const emittedRuntime = result.outputs.find((output) => output.path.endsWith(".js"));
+    if (!emittedRuntime || emittedRuntime.path === runtimePath) {
+      return;
+    }
+    fileSystem.ensureDir(path.dirname(runtimePath));
+    fileSystem.copyFile(emittedRuntime.path, runtimePath);
   }
   broadcast(event) {
     appLogger.debug(
@@ -158,6 +230,30 @@ class SharedHmrManager {
   getOutputUrl(entrypointPath) {
     return this.watchedFiles.get(entrypointPath);
   }
+  /**
+   * Returns the emitted HMR script output when the entrypoint is already registered
+   * and its browser bundle exists on disk.
+   *
+   * @remarks
+   * Disk artifacts alone are not enough: a fresh dev session must still register
+   * the entrypoint so file watchers can rebuild it on change.
+   */
+  getResolvedScriptOutput(entrypointPath) {
+    const normalizedEntrypoint = path.resolve(entrypointPath);
+    if (!this.watchedFiles.has(normalizedEntrypoint)) {
+      return void 0;
+    }
+    const { outputPath, outputUrl: derivedOutputUrl } = resolveHmrEntrypointOutputPaths(
+      this.appConfig.absolutePaths.srcDir,
+      this.distDir,
+      normalizedEntrypoint
+    );
+    if (!fileSystem.exists(outputPath)) {
+      return void 0;
+    }
+    const outputUrl = this.watchedFiles.get(normalizedEntrypoint) ?? derivedOutputUrl;
+    return { outputUrl, outputPath };
+  }
   getWatchedFiles() {
     return this.watchedFiles;
   }
@@ -175,7 +271,7 @@ class SharedHmrManager {
       getSrcDir: () => this.appConfig.absolutePaths.srcDir,
       getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
       getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
-      getBuildExecutor: () => getAppBuildExecutor(this.appConfig),
+      getBuildExecutor: () => requireBuildRuntime(this.appConfig).getProfile("browser-hmr"),
       getBrowserBundleService: () => this.browserBundleService,
       getEntrypointDependencyGraph: () => this.entrypointDependencyGraph,
       importServerModule: async (filePath) => await this.serverModuleTranspiler.importModule({
@@ -220,6 +316,16 @@ class SharedHmrManager {
       appLogger.error(`[HMR] Generic script entrypoint build failed for ${entrypointPath}:`, buildResult.logs);
       return;
     }
+    if (!fileSystem.exists(outputPath) && buildResult.outputs.length > 0) {
+      const resolvedOutputPath = path.resolve(outputPath);
+      const emittedOutput = buildResult.outputs.find((output) => path.resolve(output.path) === resolvedOutputPath)?.path ?? buildResult.outputs.find((output) => path.basename(output.path) === path.basename(outputPath))?.path;
+      if (emittedOutput && fileSystem.exists(emittedOutput)) {
+        fileSystem.ensureDir(path.dirname(outputPath));
+        if (path.resolve(emittedOutput) !== resolvedOutputPath) {
+          fileSystem.copyFile(emittedOutput, outputPath);
+        }
+      }
+    }
     const entrypointDependencies = buildResult.dependencyGraph?.entrypoints?.[entrypointPath];
     if (entrypointDependencies) {
       this.entrypointDependencyGraph.setEntrypointDependencies(entrypointPath, entrypointDependencies);
@@ -235,7 +341,11 @@ class SharedHmrManager {
     this.entrypointDependencyGraph.reset();
     this.plugins = [];
   }
+  [Symbol.dispose]() {
+    this.stop();
+  }
 }
 export {
-  SharedHmrManager
+  SharedHmrManager,
+  resolveHmrRegistrationTimeoutMs
 };

package/src/adapters/shared/static-preview-host.d.ts

@@ -7,4 +7,9 @@ export interface StaticPreviewHostStartOptions {
     appConfig: EcoPagesAppConfig;
     hostname: string;
     port: number;
+    /**
+     * When true, bind to the next available port if the preferred one is busy.
+     * Should remain false when the port was explicitly configured.
+     */
+    allowPortFallback?: boolean;
 }

package/src/adapters/shared/websocket-lifecycle.d.ts

@@ -0,0 +1,24 @@
+import type { EcopagesSocket, WebSocketCloseInfo } from '../../types/public-types.js';
+/**
+ * @remarks
+ * Bun and Node expose different raw socket types but share the same
+ * {@link OutgoingWebSocketMessage} contract. Adapters supply only `send`/`close`;
+ * {@link createEcopagesSocket} owns message normalization and stream forwarding.
+ */
+export interface WebSocketSendTransport {
+    send(data: string | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+}
+/**
+ * @remarks
+ * Bun and Node adapters previously duplicated outgoing-message dispatch and
+ * stream forwarding; this is the shared implementation both transports delegate to.
+ */
+export declare function createEcopagesSocket<TContext, TParams extends Record<string, string>>(transport: WebSocketSendTransport, meta: {
+    kind: string;
+    params: TParams;
+    search: Record<string, string>;
+    context: TContext;
+}): EcopagesSocket<TContext, TParams>;
+export declare function toWebSocketCloseInfo(code: number, reason: string): WebSocketCloseInfo;
+export declare function invokeWebSocketHandlerHook(kind: string, hookName: string, result: void | Promise<void>): void;

package/src/adapters/shared/websocket-lifecycle.js

@@ -0,0 +1,55 @@
+import { appLogger } from "../../global/app-logger.js";
+function sendOutgoingMessage(transport, message) {
+  if (typeof message === "string") {
+    transport.send(message);
+  } else if (message instanceof Blob) {
+    void message.arrayBuffer().then((buffer) => transport.send(new Uint8Array(buffer)));
+  } else if (message instanceof ArrayBuffer) {
+    transport.send(new Uint8Array(message));
+  } else if (ArrayBuffer.isView(message)) {
+    transport.send(new Uint8Array(message.buffer, message.byteOffset, message.byteLength));
+  } else {
+    transport.send(message);
+  }
+}
+function createEcopagesSocket(transport, meta) {
+  return {
+    kind: meta.kind,
+    params: meta.params,
+    search: meta.search,
+    context: meta.context,
+    send: (message) => sendOutgoingMessage(transport, message),
+    sendStream: async (stream) => {
+      const reader = stream.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          if (value) transport.send(value);
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    close: (code, reason) => transport.close(code, reason)
+  };
+}
+function toWebSocketCloseInfo(code, reason) {
+  return {
+    code,
+    reason,
+    wasClean: code === 1e3 || code === 1001
+  };
+}
+function invokeWebSocketHandlerHook(kind, hookName, result) {
+  if (result instanceof Promise) {
+    result.catch((error) => {
+      appLogger.error(`[WS:${kind}] ${hookName} failed:`, error);
+    });
+  }
+}
+export {
+  createEcopagesSocket,
+  invokeWebSocketHandlerHook,
+  toWebSocketCloseInfo
+};

package/src/build/README.md

@@ -4,13 +4,15 @@ The build layer is the bundler contract for Ecopages. One bundled adapter is the
 
 ## Mental Model
 
-Three concentric shapes, plus a serializer and a plugin injector:
+Three concentric shapes, plus profile executors and a plugin injector:
 
 | Shape                      | Lives in                       | Purpose                                                                                                                                                             |
 | -------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `BuildAdapter`             | `build-adapter.ts`             | Low-level backend. Two implementations: the bundled adapter (the real bundler) and `ViteHostBuildAdapter` (a host-owned boundary marker that throws on direct use). |
-| `BuildExecutor`            | `build-adapter.ts`             | Narrower runtime facade. Only `build` is exposed. Stored on `appConfig.runtime.buildExecutor`.                                                                      |
-| `SerializedBuildExecutor`  | `serialized-build-executor.ts` | FIFO queue around any `BuildExecutor`. Used by the dev watch pipeline.                                                                                              |
+| `BuildRuntime`             | `build-runtime.ts`             | Profile-based executor registry. Single entry point on `appConfig.runtime.buildRuntime`.                                                                            |
+| `BuildExecutor`            | `build-contracts.ts`           | Narrower runtime facade. Only `build` is exposed. Retrieved via `buildRuntime.getProfile(...)`.                                                                     |
+| `SerializedBuildExecutor`  | `serialized-build-executor.ts` | FIFO queue around any `BuildExecutor`. Used for server-entry single-flight ordering.                                                                                |
+| `ParallelBuildExecutor`    | `parallel-build-executor.ts`   | Concurrency-limited wrapper for independent route-module and HMR browser builds.                                                                                    |
 | `withBuildExecutorPlugins` | `build-adapter.ts`             | Merges app-owned plugins into every `build` call. The single point of plugin injection.                                                                             |
 
 Plus one translation bridge:
@@ -20,29 +22,31 @@ Plus one translation bridge:
 ## Files
 
 - `build-adapter.ts`: types, factories, app-owned helpers, `withBuildExecutorPlugins`.
+- `build-runtime.ts`: profile-based executor installation (`server-entry`, `route-module`, `browser-hmr`).
 - `build-types.ts`: the `EcoBuildPlugin` contract used by integrations and processors.
 - `rolldown-build-adapter.ts`: the production `BuildAdapter`. Wraps the bundler and exposes a normalized `BuildResult` (outputs, dependency graph, logs).
 - `rolldown-plugin-bridge.ts`: `EcoBuildPlugin[]` → bundler-plugin translation.
 - `serialized-build-executor.ts`: FIFO queue primitive.
-- `runtime-build-executor.ts`: dev-watch entrypoint that wraps the app-owned adapter in a `SerializedBuildExecutor + withBuildExecutorPlugins` chain.
+- `runtime-build-executor.ts`: server-adapter entrypoint that installs `BuildRuntime` via `installAppRuntimeBuildExecutor()`.
+- `server-entry-build-cache.ts`: production server-entry bundle cache (`.eco/.server-entry/.build-cache.json` + `dist/.server/manifest.json`).
 - `*.test.ts`: regression coverage.
 
 ## Default Flow
 
-`ConfigBuilder.build()` creates one app-owned adapter, manifest, executor, dev graph, and runtime registry. The executor it stores is the raw `BuildAdapter`; the plugin-wrap step lives in the runtime path.
-
-When a server adapter initializes, it calls `installAppRuntimeBuildExecutor(appConfig)`. That function reads the existing executor (or falls back to the app-owned adapter) and stores a fresh wrapper:
+`ConfigBuilder.build()` creates one app-owned adapter and manifest. When a server adapter initializes, it calls `installAppRuntimeBuildExecutor(appConfig)`, which installs `BuildRuntime`:
 
 ```
-BuildExecutor
-  └─ SerializedBuildExecutor            // FIFO queue
-       └─ withBuildExecutorPlugins       // injects app plugins
-            └─ BuildAdapter (bundled adapter or Vite-host)
+BuildRuntime.getProfile(...)
+  ├─ server-entry  → SerializedBuildExecutor → withBuildExecutorPlugins → RolldownBuildAdapter
+  ├─ route-module  → ParallelBuildExecutor   → withBuildExecutorPlugins → RolldownBuildAdapter
+  └─ browser-hmr   → ParallelBuildExecutor   → withBuildExecutorPlugins → RolldownBuildAdapter
 ```
 
-Every dev-watch caller reads `appConfig.runtime.buildExecutor` and gets the merged plugin set without further ceremony.
+All profiles use one-shot Rolldown in both dev and production. Route-module and browser-HMR builds run in parallel; server-entry stays serialized single-flight.
+
+Runtime code should call `requireBuildRuntime(appConfig).getProfile('route-module' | 'browser-hmr' | 'server-entry')` instead of reading legacy executor slots.
 
-The exported `defaultBuildAdapter` and the top-level `build()` / `getTranspileOptions()` helpers are non-app-aware escape hatches. New runtime code should prefer `getAppBuildAdapter()`, `getAppBuildExecutor()`, and `getAppTranspileOptions()`.
+The exported `defaultBuildAdapter` and the top-level `build()` / `getTranspileOptions()` helpers are non-app-aware escape hatches. New runtime code should prefer `getAppBuildAdapter()`, `requireBuildRuntime()`, and `getAppTranspileOptions()`.
 
 ## Vite-Host Boundary
 
@@ -81,11 +85,70 @@ Plugin ordering: the bundler's `resolveId` and `load` are "first" hooks. The bri
 
 These fields are kept in the type so existing call-sites compile. The proper fix is a more focused `BuildOptions` schema in a follow-up.
 
+## Dev / watch path
+
+`installBuildRuntime` (via `installAppRuntimeBuildExecutor`) installs profile-based executors:
+
+| Profile        | Backend           | Concurrency          |
+| -------------- | ----------------- | -------------------- |
+| `server-entry` | Rolldown one-shot | Serialized           |
+| `route-module` | Rolldown one-shot | Parallel             |
+| `browser-hmr`  | Rolldown one-shot | Parallel (limit ≤ 3) |
+
+`hmr-entrypoint` rebuilds use the `browser-hmr` profile. Other browser builds (`browser-script`, `hmr-runtime`) use `route-module`.
+
+`ProjectWatcher` deduplicates watch roots, ignores `.eco/` and `dist/`, and coalesces duplicate chokidar events within 150ms.
+
+## Metrics
+
+Set `ECOPAGES_ROLLDOWN_BUILD_METRICS=1` to log Rolldown invocation counts during dev and production builds. Compare kitchen-sink dev navigation and `static-build-bench` before/after runtime changes.
+
+## Production build caches
+
+Two persisted cache layers accelerate production builds. Both use `.build-cache.json` manifests keyed by dependency hashes and a build-inputs fingerprint.
+
+| Cache                                  | On-disk location                                    | Module                              |
+| -------------------------------------- | --------------------------------------------------- | ----------------------------------- |
+| Server-entry bundle                    | `.eco/.server-entry/.build-cache.json`              | `server-entry-build-cache.ts`       |
+| Route-module transpile + static render | `<server-outdir>/.server-modules/.build-cache.json` | `route-module-build-cache.store.ts` |
+
+`getInstalledServerEntryBuildExecutor()` returns the `server-entry` profile from `BuildRuntime`. `clearProductionBuildCaches()` wipes both manifest trees, resets in-memory route-module state, and clears `buildRuntime`.
+
+The route-module registry (`route-module-build-cache-registry.ts`) shares one `RouteModuleBuildCache` per `(app, outdir)` pair. Legacy `.server-route-modules` outdirs are still read for migration but new writes go to `.server-modules`.
+
+## Unified pages graph
+
+Production static exports compile all template pages in one Rolldown invocation when `shouldBuildPagesUnifiedGraph()` is true (default in production; opt out with `ECOPAGES_UNIFIED_PAGES_GRAPH=0`).
+
+| Artifact       | Location                                              |
+| -------------- | ----------------------------------------------------- |
+| Graph manifest | `.eco/.server-pages-graph/.build-cache.json`          |
+| Chunk outputs  | `.eco/.server-modules/` (shared with per-route cache) |
+
+`StaticSiteGenerator` calls `ensurePagesUnifiedGraphBuilt()` before the export loop. `PageModuleImportService` imports prebuilt chunks via `importPagesUnifiedGraphModule()` and falls back to per-page Rolldown on miss.
+
+`ECOPAGES_ROLLDOWN_BUILD_METRICS=1` enables `rolldown-build-invocation-metrics.ts` counters used by bench and parity tests.
+
+Build-input fingerprinting lives in `build-input-fingerprint.ts` and is shared with server-entry cache, unified pages graph, and static-render invalidation.
+
+## JSX Ownership Plugins
+
+Mixed-integration apps need explicit `@jsxImportSource` handling in two different shapes:
+
+| Helper                               | Use when                                  | Behavior                                                                                                                |
+| ------------------------------------ | ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `getJsxOwnershipPlugins()`           | App-wide server/transpile builds          | Each JSX integration extension gets its **own** `jsxImportSource` so native files keep their owning runtime.            |
+| `getHostScopedJsxOwnershipPlugins()` | One integration's **client** bundle graph | Foreign `.tsx`/`.jsx` files compile with the **host** integration JSX runtime (for example React bundling `.kita.tsx`). |
+| `eco-component-meta-plugin`          | Component metadata injection              | Prepends the **owning** integration pragma only when injecting `__eco` metadata into native files.                      |
+
+`foreign-jsx-override-plugin.ts` is the shared implementation. Prefer the helpers above instead of calling it directly from integrations.
+
 ## Testing Strategy
 
 - `rolldown-build-adapter.test.ts` covers the adapter's `build`, `resolve`, `getTranspileOptions`, and dependency-graph extraction end-to-end.
 - `rolldown-plugin-bridge.test.ts` covers the `EcoBuildPlugin[]` → plugin translation in isolation.
 - `build-adapter.test.ts` covers the app-owned helpers, the `BuildOwnership` routing, the `withBuildExecutorPlugins` injection, and the default-fallback behaviour.
-- `runtime-build-executor.test.ts` covers the dev-watch wrapper: serialization, plugin injection, and the Vite-host rejection path.
+- `build-runtime.test.ts` covers profile executor installation and parallelism.
+- `runtime-build-executor.test.ts` covers the runtime wrapper: plugin injection and the Vite-host rejection path.
 
 If you change option mapping or plugin-bridge semantics, update the adapter and bridge tests first. If you change the app-owned helper contracts, update `build-adapter.test.ts` first.

package/src/build/app-build-manifest-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { EcoBuildPlugin } from './build-types.js';
+import type { AppBuildManifest } from './build-manifest.js';
+import type { EcoPagesAppConfig, IHmrManager } from '../types/internal-types.js';
+export declare function collectConfiguredAppBuildManifestContributions(appConfig: EcoPagesAppConfig): Promise<Pick<AppBuildManifest, 'runtimePlugins' | 'browserBundlePlugins' | 'browserRuntimeManifest'>>;
+export declare function setupAppRuntimePlugins(options: {
+    appConfig: EcoPagesAppConfig;
+    runtimeOrigin: string;
+    hmrManager?: IHmrManager;
+    onRuntimePlugin?: (plugin: EcoBuildPlugin) => void;
+}): Promise<void>;

package/src/build/app-build-manifest-runtime.js

@@ -0,0 +1,90 @@
+import { mergeBrowserRuntimeManifests } from "./browser-runtime-manifest.js";
+import { appLogger } from "../global/app-logger.js";
+function patchAppRuntime(appConfig, patch) {
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    ...patch
+  };
+}
+function registerRuntimePlugins(appConfig, onRuntimePlugin) {
+  for (const loader of appConfig.loaders.values()) {
+    onRuntimePlugin?.(loader);
+  }
+  for (const processor of appConfig.processors.values()) {
+    if (processor.plugins) {
+      for (const plugin of processor.plugins) {
+        onRuntimePlugin?.(plugin);
+      }
+    }
+  }
+  for (const integration of appConfig.integrations) {
+    for (const plugin of integration.plugins) {
+      onRuntimePlugin?.(plugin);
+    }
+  }
+}
+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) {
+  if (options.appConfig.runtime?.runtimeAssetsPrepared) {
+    appLogger.debug("Skipped setupAppRuntimePlugins: runtime assets already prepared");
+    registerRuntimePlugins(options.appConfig, options.onRuntimePlugin);
+    return;
+  }
+  appLogger.debugTime("setupAppRuntimePlugins");
+  try {
+    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);
+      }
+    }
+    patchAppRuntime(options.appConfig, { runtimeAssetsPrepared: true });
+  } finally {
+    appLogger.debugTimeEnd("setupAppRuntimePlugins");
+  }
+}
+export {
+  collectConfiguredAppBuildManifestContributions,
+  setupAppRuntimePlugins
+};