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

package/src/adapters/shared/server-static-builder.d.ts

@@ -0,0 +1,71 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { ApiHandler, StaticRoute } from '../../types/public-types.js';
+import type { RouteRegistry } from '../../router/server/route-registry.js';
+import type { StaticSiteGenerator } from '../../static-site-generator/static-site-generator.js';
+import type { StaticGenerationRendererResolver } from '../../route-renderer/route-renderer.js';
+export interface StaticBuildOptions {
+    preview?: boolean;
+    baseUrl?: string;
+}
+export interface ServeOptions {
+    hostname?: string;
+    port?: number | string;
+}
+export interface ServerStaticBuilderParams {
+    appConfig: EcoPagesAppConfig;
+    staticSiteGenerator: StaticSiteGenerator;
+    serveOptions: ServeOptions;
+    apiHandlers?: ApiHandler[];
+    logger?: ServerStaticBuilderLogger;
+    previewServerFactory?: ServerStaticPreviewServerFactory;
+}
+/**
+ * Minimal logger dependency used by the static builder.
+ */
+export interface ServerStaticBuilderLogger {
+    warn(message: string, detail?: string): unknown;
+    info(message: string): unknown;
+    error(message: string): unknown;
+}
+/**
+ * Preview server factory dependency used when static preview mode is enabled.
+ */
+export interface ServerStaticPreviewServerFactory {
+    createServer(args: {
+        appConfig: EcoPagesAppConfig;
+        options: {
+            port: number;
+        };
+    }): {
+        server?: {
+            port?: number;
+        } | null;
+    };
+}
+/**
+ * Handles static site generation and previews.
+ */
+export declare class ServerStaticBuilder {
+    private readonly appConfig;
+    private readonly staticSiteGenerator;
+    private readonly serveOptions;
+    private readonly apiHandlers;
+    private readonly logger;
+    private readonly previewServerFactory;
+    constructor({ appConfig, staticSiteGenerator, serveOptions, apiHandlers, logger, previewServerFactory, }: ServerStaticBuilderParams);
+    private warnApiHandlersUnavailableInStaticMode;
+    private prepareExportDirectory;
+    private refreshRuntimeAssets;
+    /**
+     * Generates a static build of the site for deployment.
+     * @param options.preview - If true, starts a preview server after build
+     * @param dependencies.router - The initialized router
+     * @param dependencies.routeRendererFactory - The route renderer factory
+     * @param dependencies.staticRoutes - Explicit static routes registered via app.static()
+     */
+    build(options: StaticBuildOptions | undefined, dependencies: {
+        router: RouteRegistry;
+        routeRendererFactory: StaticGenerationRendererResolver;
+        staticRoutes?: StaticRoute[];
+    }): Promise<void>;
+}

package/src/adapters/shared/server-static-builder.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../config/constants.js";
+import { StaticContentServer } from "../../dev/sc-server.js";
+import { appLogger } from "../../global/app-logger.js";
+class ServerStaticBuilder {
+  appConfig;
+  staticSiteGenerator;
+  serveOptions;
+  apiHandlers;
+  logger;
+  previewServerFactory;
+  constructor({
+    appConfig,
+    staticSiteGenerator,
+    serveOptions,
+    apiHandlers,
+    logger,
+    previewServerFactory
+  }) {
+    this.appConfig = appConfig;
+    this.staticSiteGenerator = staticSiteGenerator;
+    this.serveOptions = serveOptions;
+    this.apiHandlers = apiHandlers ?? [];
+    this.logger = logger ?? appLogger;
+    this.previewServerFactory = previewServerFactory ?? StaticContentServer;
+  }
+  warnApiHandlersUnavailableInStaticMode() {
+    if (this.apiHandlers.length === 0) {
+      return;
+    }
+    const uniqueHandlers = Array.from(
+      new Set(this.apiHandlers.map((handler) => `${handler.method} ${handler.path}`))
+    );
+    const visibleHandlers = uniqueHandlers.slice(0, 5).join(", ");
+    const remainingCount = uniqueHandlers.length - Math.min(uniqueHandlers.length, 5);
+    const summary = remainingCount > 0 ? `${visibleHandlers}, +${remainingCount} more` : visibleHandlers;
+    this.logger.warn(
+      "Registered API endpoints are not available in static build or preview modes because no server runtime is started. They are excluded from the generated output.\n",
+      `\u27A4 ${summary}`
+    );
+  }
+  prepareExportDirectory() {
+    const exportDir = this.appConfig.absolutePaths?.distDir ?? path.join(this.appConfig.rootDir, this.appConfig.distDir);
+    fileSystem.ensureDir(exportDir, true);
+    const srcPublicDir = path.join(
+      this.appConfig.rootDir,
+      this.appConfig.srcDir ?? "src",
+      this.appConfig.publicDir ?? "public"
+    );
+    if (fileSystem.exists(srcPublicDir)) {
+      fileSystem.copyDir(srcPublicDir, exportDir);
+    }
+  }
+  async refreshRuntimeAssets() {
+    for (const processor of this.appConfig.processors.values()) {
+      await processor.setup();
+    }
+    for (const integration of this.appConfig.integrations) {
+      await integration.setup();
+    }
+  }
+  /**
+   * Generates a static build of the site for deployment.
+   * @param options.preview - If true, starts a preview server after build
+   * @param dependencies.router - The initialized router
+   * @param dependencies.routeRendererFactory - The route renderer factory
+   * @param dependencies.staticRoutes - Explicit static routes registered via app.static()
+   */
+  async build(options, dependencies) {
+    const { preview = false, baseUrl: explicitBaseUrl } = options ?? {};
+    const baseUrl = explicitBaseUrl ?? `http://${this.serveOptions.hostname || DEFAULT_ECOPAGES_HOSTNAME}:${this.serveOptions.port || DEFAULT_ECOPAGES_PORT}`;
+    this.warnApiHandlersUnavailableInStaticMode();
+    this.prepareExportDirectory();
+    await this.refreshRuntimeAssets();
+    await this.staticSiteGenerator.run({
+      router: dependencies.router,
+      baseUrl,
+      routeRendererFactory: dependencies.routeRendererFactory,
+      staticRoutes: dependencies.staticRoutes
+    });
+    if (!preview) {
+      this.logger.info("Build completed");
+      return;
+    }
+    const previewPort = this.serveOptions.port || DEFAULT_ECOPAGES_PORT;
+    const { server } = this.previewServerFactory.createServer({
+      appConfig: this.appConfig,
+      options: { port: Number(previewPort) }
+    });
+    if (server?.port) {
+      this.logger.info(`Preview running at http://localhost:${server.port}`);
+    } else {
+      this.logger.error("Failed to start preview server");
+    }
+  }
+}
+export {
+  ServerStaticBuilder
+};

package/src/adapters/shared/shared-hmr-manager.d.ts

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import type { DefaultHmrContext, EcoPagesAppConfig, IHmrManager, IClientBridge } from '../../types/internal-types.js';
+import type { EcoBuildPlugin } from '../../build/build-types.js';
+import { type HmrStrategy } from '../../hmr/hmr-strategy.js';
+import type { ClientBridgeEvent } from '../../types/public-types.js';
+import { HmrEntrypointRegistrar } from './hmr-entrypoint-registrar.js';
+import { BrowserBundleService } from '../../services/assets/browser-bundle.service.js';
+import { type EntrypointDependencyGraph } from '../../services/runtime-state/entrypoint-dependency-graph.service.js';
+import type { ServerModuleTranspiler } from '../../services/module-loading/server-module-transpiler.service.js';
+type HandleFileChangeOptions = {
+    broadcast?: boolean;
+};
+type SharedHmrManagerParams = {
+    appConfig: EcoPagesAppConfig;
+    bridge: IClientBridge;
+    registrationTimeoutMs?: number;
+};
+export declare abstract class SharedHmrManager implements IHmrManager {
+    readonly appConfig: EcoPagesAppConfig;
+    protected readonly bridge: IClientBridge;
+    protected watchers: Map<string, fs.FSWatcher>;
+    protected watchedFiles: Map<string, string>;
+    protected entrypointRegistrations: Map<string, Promise<string>>;
+    protected distDir: string;
+    protected plugins: EcoBuildPlugin[];
+    protected enabled: boolean;
+    protected strategies: HmrStrategy[];
+    protected readonly entrypointRegistrar: HmrEntrypointRegistrar;
+    protected readonly browserBundleService: BrowserBundleService;
+    protected readonly entrypointDependencyGraph: EntrypointDependencyGraph;
+    protected readonly serverModuleTranspiler: ServerModuleTranspiler;
+    constructor({ appConfig, bridge, registrationTimeoutMs }: SharedHmrManagerParams);
+    protected abstract createEntrypointDependencyGraph(existingEntrypointDependencyGraph: EntrypointDependencyGraph): EntrypointDependencyGraph;
+    protected shouldSkipMissingFileChange(_filePath: string): boolean;
+    protected onRuntimeBundleFailure(error: unknown): void;
+    protected ensureDistDir(): void;
+    protected shouldJsStrategyProcessEntrypoint(entrypointPath: string): boolean;
+    protected initializeStrategies(): void;
+    registerStrategy(strategy: HmrStrategy): void;
+    setPlugins(plugins: EcoBuildPlugin[]): void;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    buildRuntime(): Promise<void>;
+    getRuntimePath(): string;
+    broadcast(event: ClientBridgeEvent): void;
+    handleFileChange(filePath: string, options?: HandleFileChangeOptions): Promise<void>;
+    getOutputUrl(entrypointPath: string): string | undefined;
+    getWatchedFiles(): Map<string, string>;
+    getDistDir(): string;
+    getPlugins(): EcoBuildPlugin[];
+    getDefaultContext(): DefaultHmrContext;
+    protected clearFailedEntrypointRegistration(entrypointPath: string): void;
+    registerEntrypoint(entrypointPath: string): Promise<string>;
+    registerScriptEntrypoint(entrypointPath: string): Promise<string>;
+    protected emitStrictEntrypoint(entrypointPath: string): Promise<void>;
+    protected emitScriptEntrypoint(entrypointPath: string, outputPath: string): Promise<void>;
+    stop(): void;
+}
+export {};

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

@@ -0,0 +1,241 @@
+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 { 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 { appLogger } from "../../global/app-logger.js";
+import { HmrEntrypointRegistrar } from "./hmr-entrypoint-registrar.js";
+import { BrowserBundleService } from "../../services/assets/browser-bundle.service.js";
+import { getAppServerModuleTranspiler } from "../../services/module-loading/app-server-module-transpiler.service.js";
+import {
+  getAppEntrypointDependencyGraph,
+  setAppEntrypointDependencyGraph
+} from "../../services/runtime-state/entrypoint-dependency-graph.service.js";
+import { resolveInternalExecutionDir, resolveInternalWorkDir } from "../../utils/resolve-work-dir.js";
+class SharedHmrManager {
+  appConfig;
+  bridge;
+  watchers = /* @__PURE__ */ new Map();
+  watchedFiles = /* @__PURE__ */ new Map();
+  entrypointRegistrations = /* @__PURE__ */ new Map();
+  distDir;
+  plugins = [];
+  enabled = true;
+  strategies = [];
+  entrypointRegistrar;
+  browserBundleService;
+  entrypointDependencyGraph;
+  serverModuleTranspiler;
+  constructor({ appConfig, bridge, registrationTimeoutMs = 4e3 }) {
+    this.appConfig = appConfig;
+    this.bridge = bridge;
+    this.distDir = path.join(resolveInternalWorkDir(this.appConfig), RESOLVED_ASSETS_DIR, "_hmr");
+    this.entrypointRegistrar = new HmrEntrypointRegistrar({
+      srcDir: this.appConfig.absolutePaths.srcDir,
+      distDir: this.distDir,
+      entrypointRegistrations: this.entrypointRegistrations,
+      watchedFiles: this.watchedFiles,
+      clearFailedRegistration: (entrypointPath) => this.clearFailedEntrypointRegistration(entrypointPath),
+      registrationTimeoutMs
+    });
+    this.browserBundleService = new BrowserBundleService(appConfig);
+    this.entrypointDependencyGraph = this.createEntrypointDependencyGraph(
+      getAppEntrypointDependencyGraph(appConfig)
+    );
+    setAppEntrypointDependencyGraph(this.appConfig, this.entrypointDependencyGraph);
+    this.serverModuleTranspiler = getAppServerModuleTranspiler(this.appConfig);
+    this.ensureDistDir();
+    this.initializeStrategies();
+  }
+  shouldSkipMissingFileChange(_filePath) {
+    return false;
+  }
+  onRuntimeBundleFailure(error) {
+    appLogger.error("[HMR] Failed to build runtime script:", error);
+  }
+  ensureDistDir() {
+    fileSystem.ensureDir(this.distDir);
+  }
+  shouldJsStrategyProcessEntrypoint(entrypointPath) {
+    return !this.strategies.some((strategy) => {
+      if (strategy.type !== HmrStrategyType.INTEGRATION || strategy.priority <= HmrStrategyType.SCRIPT) {
+        return false;
+      }
+      try {
+        return strategy.matches(entrypointPath);
+      } catch (error) {
+        appLogger.error(error);
+        return false;
+      }
+    });
+  }
+  initializeStrategies() {
+    const jsContext = {
+      getWatchedFiles: () => this.watchedFiles,
+      getDistDir: () => this.distDir,
+      getPlugins: () => this.plugins,
+      getSrcDir: () => this.appConfig.absolutePaths.srcDir,
+      getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
+      getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
+      getTemplateExtensions: () => this.appConfig.templatesExt,
+      getBrowserBundleService: () => this.browserBundleService,
+      getEntrypointDependencyGraph: () => this.entrypointDependencyGraph,
+      shouldProcessEntrypoint: (entrypointPath) => this.shouldJsStrategyProcessEntrypoint(entrypointPath)
+    };
+    this.strategies = [new JsHmrStrategy(jsContext), new DefaultHmrStrategy()];
+  }
+  registerStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+  setPlugins(plugins) {
+    this.plugins = [...plugins];
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  async buildRuntime() {
+    const runtimeSource = fileURLToPath(import.meta.resolve("@ecopages/core/hmr/client/hmr-runtime"));
+    try {
+      const result = await this.browserBundleService.bundle({
+        profile: "hmr-runtime",
+        entrypoints: [runtimeSource],
+        outdir: this.distDir,
+        naming: "_hmr_runtime.js",
+        minify: false,
+        plugins: this.plugins
+      });
+      if (!result.success) {
+        this.onRuntimeBundleFailure(result.logs);
+      }
+    } catch (error) {
+      this.onRuntimeBundleFailure(error);
+    }
+  }
+  getRuntimePath() {
+    return path.join(this.distDir, "_hmr_runtime.js");
+  }
+  broadcast(event) {
+    appLogger.debug(
+      `[HMR] Broadcasting ${event.type} event, path=${event.path || "all"}, subscribers=${this.bridge.subscriberCount}`
+    );
+    this.bridge.broadcast(event);
+  }
+  async handleFileChange(filePath, options = {}) {
+    if (this.shouldSkipMissingFileChange(filePath) && !fileSystem.exists(filePath)) {
+      appLogger.debug(`[${this.constructor.name}] Skipping missing file change: ${filePath}`);
+      this.clearFailedEntrypointRegistration(filePath);
+      return;
+    }
+    const sorted = [...this.strategies].sort((a, b) => b.priority - a.priority);
+    const strategy = sorted.find((candidate) => {
+      try {
+        return candidate.matches(filePath);
+      } catch (error) {
+        appLogger.error(error);
+        return false;
+      }
+    });
+    if (!strategy) {
+      appLogger.warn(`[HMR] No strategy found for ${filePath}`);
+      return;
+    }
+    appLogger.debug(`[${this.constructor.name}] Selected strategy: ${strategy.constructor.name}`);
+    const action = await strategy.process(filePath);
+    const shouldBroadcast = options.broadcast ?? true;
+    if (shouldBroadcast && action.type === "broadcast" && action.events) {
+      for (const event of action.events) {
+        this.broadcast(event);
+      }
+    }
+  }
+  getOutputUrl(entrypointPath) {
+    return this.watchedFiles.get(entrypointPath);
+  }
+  getWatchedFiles() {
+    return this.watchedFiles;
+  }
+  getDistDir() {
+    return this.distDir;
+  }
+  getPlugins() {
+    return this.plugins;
+  }
+  getDefaultContext() {
+    return {
+      getWatchedFiles: () => this.watchedFiles,
+      getDistDir: () => this.distDir,
+      getPlugins: () => this.plugins,
+      getSrcDir: () => this.appConfig.absolutePaths.srcDir,
+      getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
+      getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
+      getBuildExecutor: () => getAppBuildExecutor(this.appConfig),
+      getBrowserBundleService: () => this.browserBundleService,
+      getEntrypointDependencyGraph: () => this.entrypointDependencyGraph,
+      importServerModule: async (filePath) => await this.serverModuleTranspiler.importModule({
+        filePath,
+        outdir: path.join(resolveInternalExecutionDir(this.appConfig), ".server-modules"),
+        externalPackages: true
+      })
+    };
+  }
+  clearFailedEntrypointRegistration(entrypointPath) {
+    this.watchedFiles.delete(entrypointPath);
+    this.entrypointDependencyGraph.clearEntrypointDependencies(entrypointPath);
+  }
+  async registerEntrypoint(entrypointPath) {
+    return await this.entrypointRegistrar.registerEntrypoint(entrypointPath, {
+      emit: async (normalizedEntrypoint) => await this.emitStrictEntrypoint(normalizedEntrypoint),
+      getMissingOutputError: (normalizedEntrypoint, outputPath) => new Error(
+        `[HMR] Integration failed to emit entrypoint ${normalizedEntrypoint} to ${outputPath}. Page entrypoints must be produced by their owning integration.`
+      )
+    });
+  }
+  async registerScriptEntrypoint(entrypointPath) {
+    return await this.entrypointRegistrar.registerEntrypoint(entrypointPath, {
+      emit: async (normalizedEntrypoint, outputPath) => await this.emitScriptEntrypoint(normalizedEntrypoint, outputPath),
+      getMissingOutputError: (normalizedEntrypoint) => new Error(`[HMR] Failed to register script entrypoint: ${normalizedEntrypoint}`)
+    });
+  }
+  async emitStrictEntrypoint(entrypointPath) {
+    await this.handleFileChange(entrypointPath, { broadcast: false });
+  }
+  async emitScriptEntrypoint(entrypointPath, outputPath) {
+    const naming = path.relative(this.distDir, outputPath).split(path.sep).join("/");
+    const buildResult = await this.browserBundleService.bundle({
+      profile: "hmr-entrypoint",
+      entrypoints: [entrypointPath],
+      outdir: this.distDir,
+      naming,
+      minify: false,
+      plugins: this.plugins
+    });
+    if (!buildResult.success) {
+      appLogger.error(`[HMR] Generic script entrypoint build failed for ${entrypointPath}:`, buildResult.logs);
+      return;
+    }
+    const entrypointDependencies = buildResult.dependencyGraph?.entrypoints?.[entrypointPath];
+    if (entrypointDependencies) {
+      this.entrypointDependencyGraph.setEntrypointDependencies(entrypointPath, entrypointDependencies);
+    }
+  }
+  stop() {
+    this.entrypointRegistrations.clear();
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    this.watchedFiles.clear();
+    this.entrypointDependencyGraph.reset();
+    this.plugins = [];
+  }
+}
+export {
+  SharedHmrManager
+};

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

@@ -0,0 +1,10 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+export interface StaticPreviewHost {
+    start(options: StaticPreviewHostStartOptions): Promise<number | null>;
+    stop(force?: boolean): Promise<void>;
+}
+export interface StaticPreviewHostStartOptions {
+    appConfig: EcoPagesAppConfig;
+    hostname: string;
+    port: number;
+}

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

@@ -0,0 +1,31 @@
+export type BrowserRuntimeMode = 'development' | 'production';
+export type BrowserRuntimeAssetDeclaration = {
+    /** Bare or virtual specifier used by authored/generated browser modules. */
+    specifier: string;
+    /** Integration, processor, or core subsystem that owns this runtime asset. */
+    owner: string;
+    /** Source import path used to build or resolve the runtime asset. */
+    importPath: string;
+    /** Concrete browser URL emitted or served for this runtime asset. */
+    publicPath: string;
+    /** Runtime mode this declaration applies to. Omit when the URL is mode-independent. */
+    mode?: BrowserRuntimeMode;
+    /** Specifiers that should be treated as external while building this runtime asset. */
+    externals?: readonly string[];
+};
+export type BrowserRuntimeAsset = BrowserRuntimeAssetDeclaration & {
+    externals: readonly string[];
+};
+export type BrowserRuntimeManifest = {
+    assets: readonly BrowserRuntimeAsset[];
+    bySpecifier: ReadonlyMap<string, BrowserRuntimeAsset>;
+};
+export declare class BrowserRuntimeManifestConflictError extends Error {
+    readonly specifier: string;
+    readonly existing: BrowserRuntimeAsset;
+    readonly incoming: BrowserRuntimeAsset;
+    constructor(specifier: string, existing: BrowserRuntimeAsset, incoming: BrowserRuntimeAsset);
+}
+export declare function createBrowserRuntimeManifest(declarations?: readonly BrowserRuntimeAssetDeclaration[]): BrowserRuntimeManifest;
+export declare function mergeBrowserRuntimeManifests(...manifests: Array<BrowserRuntimeManifest | undefined>): BrowserRuntimeManifest;
+export declare function getBrowserRuntimeSpecifierMap(manifest: BrowserRuntimeManifest): ReadonlyMap<string, string>;

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

@@ -0,0 +1,61 @@
+class BrowserRuntimeManifestConflictError extends Error {
+  specifier;
+  existing;
+  incoming;
+  constructor(specifier, existing, incoming) {
+    super(
+      `Browser runtime asset conflict for ${specifier}: ${existing.owner} maps to ${existing.publicPath}, ${incoming.owner} maps to ${incoming.publicPath}`
+    );
+    this.name = "BrowserRuntimeManifestConflictError";
+    this.specifier = specifier;
+    this.existing = existing;
+    this.incoming = incoming;
+  }
+}
+function normalizeDeclaration(declaration) {
+  return {
+    ...declaration,
+    externals: declaration.externals ?? []
+  };
+}
+function hasCompatibleRuntimeAsset(existing, incoming) {
+  return existing.owner === incoming.owner && existing.importPath === incoming.importPath && existing.publicPath === incoming.publicPath && existing.mode === incoming.mode && arrayEquals(existing.externals, incoming.externals);
+}
+function arrayEquals(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  return left.every((value, index) => value === right[index]);
+}
+function createBrowserRuntimeManifest(declarations = []) {
+  const assets = [];
+  const bySpecifier = /* @__PURE__ */ new Map();
+  for (const declaration of declarations) {
+    const asset = normalizeDeclaration(declaration);
+    const existing = bySpecifier.get(asset.specifier);
+    if (existing) {
+      if (!hasCompatibleRuntimeAsset(existing, asset)) {
+        throw new BrowserRuntimeManifestConflictError(asset.specifier, existing, asset);
+      }
+      continue;
+    }
+    assets.push(asset);
+    bySpecifier.set(asset.specifier, asset);
+  }
+  return {
+    assets,
+    bySpecifier
+  };
+}
+function mergeBrowserRuntimeManifests(...manifests) {
+  return createBrowserRuntimeManifest(manifests.flatMap((manifest) => manifest?.assets ?? []));
+}
+function getBrowserRuntimeSpecifierMap(manifest) {
+  return new Map(manifest.assets.map((asset) => [asset.specifier, asset.publicPath]));
+}
+export {
+  BrowserRuntimeManifestConflictError,
+  createBrowserRuntimeManifest,
+  getBrowserRuntimeSpecifierMap,
+  mergeBrowserRuntimeManifests
+};

package/src/build/{browser-runtime-plugin-helpers.ts → browser-runtime-plugin-helpers.d.ts}

@@ -10,16 +10,12 @@
  * These utilities are extracted here so the plugin does not duplicate
  * the same code path.
  */
-
 /**
  * Escapes a literal specifier for inclusion in a regular expression.
  *
  * Only the regex metacharacters are escaped: `. * + ? ^ $ { } ( ) | [ ] \`
  */
-export function escapeRegExp(value: string): string {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
+export declare function escapeRegExp(value: string): string;
 /**
  * Builds a `RegExp` whose alternation matches any of the keys in
  * `specifierMap`.
@@ -27,11 +23,4 @@ export function escapeRegExp(value: string): string {
  * Returns `null` for an empty map so callers can short-circuit and
  * avoid registering a no-op `onResolve` / `onLoad` filter.
  */
-export function buildSpecifierFilter(specifierMap: ReadonlyMap<string, string>): RegExp | null {
-	if (specifierMap.size === 0) {
-		return null;
-	}
-
-	const alternation = Array.from(specifierMap.keys()).map(escapeRegExp).join('|');
-	return new RegExp(`^(${alternation})$`);
-}
+export declare function buildSpecifierFilter(specifierMap: ReadonlyMap<string, string>): RegExp | null;

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

@@ -0,0 +1,14 @@
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildSpecifierFilter(specifierMap) {
+  if (specifierMap.size === 0) {
+    return null;
+  }
+  const alternation = Array.from(specifierMap.keys()).map(escapeRegExp).join("|");
+  return new RegExp(`^(${alternation})$`);
+}
+export {
+  buildSpecifierFilter,
+  escapeRegExp
+};