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

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

@@ -1,432 +1,446 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { RESOLVED_ASSETS_DIR } from "../../../config/constants.js";
-import {
-  removeStaleHmrEntrypointOutput,
-  isRegisteredScriptEntrypoint,
-  isBrowserOnlyRegisteredScriptEntrypoint
-} from "../../../hmr/hmr-entrypoint-output.js";
-import { requireBuildRuntime } from "../../../build/runtime/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";
-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();
-  distDir;
-  enabled = false;
-  strategies = [];
-  entrypointRegistrar;
-  browserBundleService;
-  invalidationService;
-  entrypointDependencyGraph;
-  serverModuleTranspiler;
-  runtimeBuildPromise = null;
-  runtimeReady = false;
-  constructor({ appConfig, bridge }) {
-    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,
-      clearFailedRegistration: (entrypointPath) => this.clearFailedEntrypointRegistration(entrypointPath)
-    });
-    this.browserBundleService = new BrowserBundleService(appConfig);
-    this.invalidationService = new DevelopmentInvalidationService(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.entrypointRegistrar.getWatchedFiles(),
-      getDistDir: () => this.distDir,
-      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 ServerRenderedTemplateHmrStrategy(this.invalidationService),
-      new DefaultHmrStrategy()
-    ];
-  }
-  registerStrategy(strategy) {
-    this.strategies.push(strategy);
-  }
-  setEnabled(enabled) {
-    this.enabled = enabled;
-  }
-  isEnabled() {
-    return this.enabled;
-  }
-  isRuntimeReady() {
-    return this.runtimeReady && fileSystem.exists(this.getRuntimePath());
-  }
-  /**
-   * Builds the browser HMR runtime once per manager session and reuses the in-flight build for concurrent callers.
-   */
-  async ensureRuntimeReady() {
-    if (this.runtimeReady) {
-      return true;
-    }
-    if (this.runtimeBuildPromise) {
-      return this.runtimeBuildPromise;
-    }
-    this.runtimeBuildPromise = this.buildRuntimeInternal();
-    try {
-      const ready = await this.runtimeBuildPromise;
-      this.runtimeReady = ready;
-      return ready;
-    } 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"));
-    const runtimePath = this.getRuntimePath();
-    removeStaleHmrEntrypointOutput(runtimePath, "HMR");
-    try {
-      const result = await this.browserBundleService.bundle({
-        profile: "hmr-runtime",
-        entrypoints: [runtimeSource],
-        outdir: this.distDir,
-        naming: "_hmr_runtime.js",
-        minify: false
-      });
-      if (!result.success) {
-        this.onRuntimeBundleFailure(result.logs);
-        return false;
-      }
-      const emittedRuntime = result.outputs.find(
-        (output) => path.resolve(output.path) === path.resolve(runtimePath)
-      );
-      if (!emittedRuntime || !fileSystem.exists(runtimePath)) {
-        this.onRuntimeBundleFailure(
-          new Error(`[HMR] Runtime bundle missing expected output at ${runtimePath}`)
-        );
-        return false;
-      }
-      return true;
-    } catch (error) {
-      this.onRuntimeBundleFailure(error);
-      return false;
-    }
-  }
-  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 = {}) {
-    const resolvedFilePath = path.resolve(filePath);
-    if (this.shouldSkipMissingFileChange(filePath) && !fileSystem.exists(filePath)) {
-      appLogger.debug(`[${this.constructor.name}] Skipping missing file change: ${filePath}`);
-      this.clearFailedEntrypointRegistration(filePath);
-      return;
-    }
-    if (isRegisteredScriptEntrypoint(this.entrypointRegistrar.getRegistered(), resolvedFilePath)) {
-      await this.prepareRegisteredScriptChange(resolvedFilePath);
-    }
-    const shouldBroadcast = options.broadcast ?? true;
-    const strategy = this.selectChangeStrategy(filePath);
-    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);
-    if (shouldBroadcast && action.type === "broadcast" && action.events) {
-      if (this.bridge.subscriberCount === 0) {
-        appLogger.debug(
-          `[${this.constructor.name}] Deferring HMR client broadcast for ${filePath} until a subscriber connects`
-        );
-        return;
-      }
-      for (const event of action.events) {
-        const graphIdentities = event.graphIdentities ?? options.graphIdentities;
-        this.broadcast(graphIdentities === void 0 ? event : { ...event, graphIdentities });
-      }
-    }
-  }
-  getStrategiesByPriority() {
-    return [...this.strategies].sort((left, right) => right.priority - left.priority);
-  }
-  selectChangeStrategy(filePath) {
-    return this.getStrategiesByPriority().find((candidate) => {
-      try {
-        return candidate.matches(filePath);
-      } catch (error) {
-        appLogger.error(error);
-        return false;
-      }
-    });
-  }
-  selectEntrypointEmitter(entrypointPath) {
-    return this.getStrategiesByPriority().find((candidate) => {
-      if (candidate.type !== HmrStrategyType.INTEGRATION) {
-        return false;
-      }
-      try {
-        return candidate.canEmitEntrypoint(entrypointPath);
-      } catch (error) {
-        appLogger.error(error);
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { HMR_RUNTIME_SCRIPT_URL, resolveHmrRuntimeWorkDir } from '../../../hmr/hmr-runtime-paths.js';
+import { DEV_TOOLBAR_RUNTIME_SCRIPT_URL, resolveDevToolbarRuntimeWorkDir, } from '../../../dev-toolbar/dev-toolbar-runtime-paths.js';
+import { DevToolbarHost } from '../../../dev-toolbar/dev-toolbar-host.js';
+import { isDevTransformModuleUrl } from '../../../hmr/hmr-asset-paths.js';
+import { removeStaleHmrEntrypointOutput, isRegisteredDevTransformEntrypoint, isRegisteredScriptEntrypoint, } from '../../../hmr/hmr-entrypoint-output.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 { DevTransformEntrypointRegistry } from './dev-transform-entrypoint-registry.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';
+import { DevTransformServer } from '../../../dev/transform-server/dev-transform-server.js';
+export class SharedHmrManager {
+    appConfig;
+    bridge;
+    watchers = new Map();
+    runtimeWorkDir;
+    enabled = false;
+    strategies = [];
+    registeredScriptReloadRequired = new Set();
+    entrypointRegistry;
+    browserBundleService;
+    invalidationService;
+    entrypointDependencyGraph;
+    serverModuleTranspiler;
+    runtimeBuildPromise = null;
+    runtimeReady = false;
+    devToolbarWorkDir;
+    devToolbarBuildPromise = null;
+    devToolbarReady = false;
+    devTransformServer;
+    constructor({ appConfig, bridge }) {
+        this.appConfig = appConfig;
+        this.bridge = bridge;
+        this.runtimeWorkDir = resolveHmrRuntimeWorkDir(resolveInternalWorkDir(this.appConfig));
+        this.devToolbarWorkDir = resolveDevToolbarRuntimeWorkDir(resolveInternalWorkDir(this.appConfig));
+        this.entrypointRegistry = new DevTransformEntrypointRegistry();
+        this.browserBundleService = new BrowserBundleService(appConfig);
+        this.invalidationService = new DevelopmentInvalidationService(appConfig);
+        this.entrypointDependencyGraph = this.createEntrypointDependencyGraph(getAppEntrypointDependencyGraph(appConfig));
+        setAppEntrypointDependencyGraph(this.appConfig, this.entrypointDependencyGraph);
+        this.serverModuleTranspiler = getAppServerModuleTranspiler(this.appConfig);
+        this.devTransformServer = new DevTransformServer({
+            appConfig: this.appConfig,
+            onModuleDependencies: (modulePath, dependencies) => {
+                this.entrypointDependencyGraph.setEntrypointDependencies(modulePath, dependencies);
+            },
+        });
+        this.ensureRuntimeWorkDir();
+        this.initializeStrategies();
+    }
+    shouldSkipMissingFileChange(_filePath) {
         return false;
-      }
-    });
-  }
-  createUnownedEntrypointError(entrypointPath) {
-    return new Error(
-      `[HMR] No integration owns entrypoint ${entrypointPath}. Page entrypoints must be emitted by their owning integration.`
-    );
-  }
-  /**
-   * Materializes one integration-owned page entrypoint during cold registration.
-   *
-   * @remarks
-   * Registration uses {@link HmrStrategy.canEmitEntrypoint} / {@link HmrStrategy.emitEntrypoint},
-   * not {@link HmrStrategy.matches} / {@link HmrStrategy.process}. File-change handling stays
-   * on `handleFileChange()`.
-   */
-  async emitIntegrationEntrypoint(entrypointPath, outputPath) {
-    const emitter = this.selectEntrypointEmitter(entrypointPath);
-    if (!emitter) {
-      throw this.createUnownedEntrypointError(entrypointPath);
-    }
-    appLogger.debug(`[${this.constructor.name}] Selected entrypoint emitter: ${emitter.constructor.name}`);
-    await emitter.emitEntrypoint(entrypointPath, outputPath);
-  }
-  /**
-   * Runs server invalidation and integration hooks before rebuilding a registered script entrypoint.
-   *
-   * @remarks
-   * Browser-only `*.script.ts` entrypoints skip server module invalidation and bypass-cache
-   * import; only integration change handlers and the downstream strategy rebuild run.
-   */
-  async prepareRegisteredScriptChange(filePath) {
-    const isBrowserOnlyRegisteredScript = isBrowserOnlyRegisteredScriptEntrypoint(filePath);
-    if (!isBrowserOnlyRegisteredScript) {
-      this.invalidationService.invalidateServerModules([filePath]);
-    }
-    const handlers = this.appConfig.runtime?.registeredScriptEntrypointChangeHandlers ?? [];
-    for (const handler of handlers) {
-      try {
-        await handler(filePath);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : `Failed to handle registered script entrypoint change for ${filePath}: ${String(error)}`;
-        this.broadcast({ type: "error", message });
-        throw error;
-      }
-    }
-    if (isBrowserOnlyRegisteredScript) {
-      return;
-    }
-    const appModuleLoader = this.appConfig.runtime?.appModuleLoader;
-    if (!appModuleLoader) {
-      return;
-    }
-    await appModuleLoader.importModule({
-      filePath,
-      rootDir: this.appConfig.rootDir,
-      outdir: path.join(resolveInternalExecutionDir(this.appConfig), ".server-modules"),
-      externalPackages: true,
-      bypassCache: true
-    });
-  }
-  getOutputUrl(entrypointPath) {
-    return this.entrypointRegistrar.getRegistered().get(path.resolve(entrypointPath))?.outputUrl;
-  }
-  /**
-   * Registers an already-materialized HMR entrypoint without rebuilding it.
-   *
-   * @remarks
-   * Cold dev batches build grouped Rolldown passes up front and then seed the
-   * registrar so the first SSR resolves the artifact from disk. The entrypoint
-   * is also added to the watched files so subsequent source edits still rebuild.
-   */
-  seedResolvedEntrypoint(resolved) {
-    this.entrypointRegistrar.seedResolvedEntrypoint(resolved);
-  }
-  /**
-   * 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);
-    const registered = this.entrypointRegistrar.getRegistered().get(normalizedEntrypoint);
-    if (!registered || !fileSystem.exists(registered.outputPath)) {
-      return void 0;
-    }
-    return registered;
-  }
-  getWatchedFiles() {
-    return this.entrypointRegistrar.getWatchedFiles();
-  }
-  tryHandleAssetRequest(request) {
-    const url = new URL(request.url);
-    if (url.pathname === "/_hmr_runtime.js") {
-      const runtimePath = this.getRuntimePath();
-      if (fileSystem.exists(runtimePath)) {
-        return new Response(fileSystem.readFileAsBuffer(runtimePath), {
-          headers: {
-            "Content-Type": "application/javascript",
-            "Cache-Control": "no-store, must-revalidate"
-          }
+    }
+    onRuntimeBundleFailure(error) {
+        appLogger.error('[HMR] Failed to build runtime script:', error);
+    }
+    ensureRuntimeWorkDir() {
+        fileSystem.ensureDir(this.runtimeWorkDir);
+        if (this.shouldBuildDevToolbar()) {
+            fileSystem.ensureDir(this.devToolbarWorkDir);
+        }
+    }
+    shouldBuildDevToolbar() {
+        return this.getDevToolbarHost().isEnabled();
+    }
+    getDevToolbarHost() {
+        return DevToolbarHost.forApp(this.appConfig, { watch: this.enabled });
+    }
+    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;
+            }
         });
-      }
-    }
-    if (url.pathname.startsWith("/assets/_hmr/")) {
-      const relativePath = url.pathname.slice("/assets/_hmr/".length);
-      const assetPath = path.join(this.distDir, relativePath);
-      if (fileSystem.exists(assetPath)) {
-        return new Response(fileSystem.readFileAsBuffer(assetPath), {
-          headers: {
-            "Content-Type": "application/javascript",
-            "Cache-Control": "no-store, must-revalidate"
-          }
+    }
+    registerDevTransformContributor(contributor) {
+        this.devTransformServer.addContributor(contributor);
+    }
+    initializeStrategies() {
+        const jsContext = {
+            getWatchedFiles: () => this.entrypointRegistry.getWatchedOutputUrls(),
+            getRegisteredEntrypoints: () => this.entrypointRegistry.getRegisteredEntrypoints(),
+            getSrcDir: () => this.appConfig.absolutePaths.srcDir,
+            getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
+            getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
+            getTemplateExtensions: () => this.appConfig.templatesExt,
+            getEntrypointDependencyGraph: () => this.entrypointDependencyGraph,
+            shouldProcessEntrypoint: (entrypointPath) => this.shouldJsStrategyProcessEntrypoint(entrypointPath),
+            invalidateDevTransformSource: (sourcePath) => this.devTransformServer.invalidateSource(sourcePath),
+            consumeRegisteredScriptReloadRequired: (sourcePath) => this.consumeRegisteredScriptReloadRequired(sourcePath),
+        };
+        this.strategies = [
+            new JsHmrStrategy(jsContext),
+            new ServerRenderedTemplateHmrStrategy(this.invalidationService),
+            new DefaultHmrStrategy(),
+        ];
+    }
+    registerStrategy(strategy) {
+        this.strategies.push(strategy);
+    }
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    isEnabled() {
+        return this.enabled;
+    }
+    isRuntimeReady() {
+        return this.runtimeReady && fileSystem.exists(this.getRuntimePath());
+    }
+    /**
+     * Builds the browser HMR runtime once per manager session and reuses the in-flight build for concurrent callers.
+     */
+    async ensureRuntimeReady() {
+        const [hmrReady, devToolbarReady] = await Promise.all([
+            this.ensureHmrRuntimeReady(),
+            this.ensureDevToolbarRuntimeReady(),
+        ]);
+        return hmrReady && devToolbarReady;
+    }
+    async ensureHmrRuntimeReady() {
+        if (this.runtimeReady) {
+            return true;
+        }
+        if (this.runtimeBuildPromise) {
+            return this.runtimeBuildPromise;
+        }
+        this.runtimeBuildPromise = this.buildRuntimeInternal();
+        try {
+            const ready = await this.runtimeBuildPromise;
+            this.runtimeReady = ready;
+            return ready;
+        }
+        finally {
+            this.runtimeBuildPromise = null;
+        }
+    }
+    async ensureDevToolbarRuntimeReady() {
+        if (!this.shouldBuildDevToolbar()) {
+            return true;
+        }
+        if (this.devToolbarReady) {
+            return true;
+        }
+        if (this.devToolbarBuildPromise) {
+            return this.devToolbarBuildPromise;
+        }
+        this.devToolbarBuildPromise = this.buildDevToolbarRuntimeInternal();
+        try {
+            const ready = await this.devToolbarBuildPromise;
+            this.devToolbarReady = ready;
+            return ready;
+        }
+        finally {
+            this.devToolbarBuildPromise = null;
+        }
+    }
+    async buildRuntime() {
+        await this.ensureRuntimeReady();
+    }
+    getRuntimePath() {
+        return path.join(this.runtimeWorkDir, path.basename(HMR_RUNTIME_SCRIPT_URL));
+    }
+    async buildDevToolbarRuntimeInternal() {
+        return this.getDevToolbarHost().bundleClientRuntime({
+            browserBundleService: this.browserBundleService,
+            workDir: this.devToolbarWorkDir,
+            onFailure: (error) => this.onRuntimeBundleFailure(error),
         });
-      }
-    }
-    return null;
-  }
-  getDistDir() {
-    return this.distDir;
-  }
-  getDefaultContext() {
-    return {
-      getWatchedFiles: () => this.entrypointRegistrar.getWatchedFiles(),
-      getDistDir: () => this.distDir,
-      getSrcDir: () => this.appConfig.absolutePaths.srcDir,
-      getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
-      getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
-      getBuildExecutor: () => requireBuildRuntime(this.appConfig).getProfile("browser-hmr"),
-      getBrowserBundleService: () => this.browserBundleService,
-      getEntrypointDependencyGraph: () => this.entrypointDependencyGraph,
-      seedResolvedEntrypoint: (resolved) => this.seedResolvedEntrypoint(resolved),
-      importServerModule: async (filePath) => await this.serverModuleTranspiler.importModule({
-        filePath,
-        outdir: path.join(resolveInternalExecutionDir(this.appConfig), ".server-modules"),
-        externalPackages: true
-      })
-    };
-  }
-  stop() {
-    this.runtimeReady = false;
-    this.entrypointRegistrar.clearAll();
-    for (const watcher of this.watchers.values()) {
-      watcher.close();
-    }
-    this.watchers.clear();
-    this.entrypointDependencyGraph.reset();
-  }
-  clearFailedEntrypointRegistration(entrypointPath) {
-    this.entrypointRegistrar.clearRegistration(entrypointPath);
-    this.entrypointDependencyGraph.clearEntrypointDependencies(entrypointPath);
-  }
-  async registerEntrypoint(entrypointPath) {
-    const resolved = await this.entrypointRegistrar.registerEntrypoint(entrypointPath, {
-      emit: async (normalizedEntrypoint, outputPath) => await this.emitIntegrationEntrypoint(normalizedEntrypoint, outputPath),
-      getMissingOutputError: (normalizedEntrypoint, outputPath) => new Error(
-        `[HMR] Integration failed to emit entrypoint ${normalizedEntrypoint} to ${outputPath}. Page entrypoints must be produced by their owning integration.`
-      )
-    });
-    return resolved.outputUrl;
-  }
-  async registerScriptEntrypoint(entrypointPath) {
-    return await this.entrypointRegistrar.registerEntrypoint(entrypointPath, {
-      emit: async (normalizedEntrypoint, outputPath) => await this.emitScriptEntrypoint(normalizedEntrypoint, outputPath),
-      getMissingOutputError: (normalizedEntrypoint, outputPath) => new Error(`[HMR] Failed to register script entrypoint: ${normalizedEntrypoint} to ${outputPath}`)
-    });
-  }
-  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
-    });
-    if (!buildResult.success) {
-      throw new Error(
-        `[HMR] Generic script entrypoint build failed for ${entrypointPath}: ${JSON.stringify(buildResult.logs)}`
-      );
-    }
-    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);
+    }
+    getDevToolbarRuntimePath() {
+        return path.join(this.devToolbarWorkDir, path.basename(DEV_TOOLBAR_RUNTIME_SCRIPT_URL));
+    }
+    async buildRuntimeInternal() {
+        const runtimeSource = fileURLToPath(import.meta.resolve('@ecopages/core/hmr/client/hmr-runtime'));
+        const runtimePath = this.getRuntimePath();
+        removeStaleHmrEntrypointOutput(runtimePath, 'HMR');
+        try {
+            const result = await this.browserBundleService.bundle({
+                profile: 'hmr-runtime',
+                entrypoints: [runtimeSource],
+                outdir: this.runtimeWorkDir,
+                naming: path.basename(HMR_RUNTIME_SCRIPT_URL),
+                minify: false,
+            });
+            if (!result.success) {
+                this.onRuntimeBundleFailure(result.logs);
+                return false;
+            }
+            const emittedRuntime = result.outputs.find((output) => path.resolve(output.path) === path.resolve(runtimePath));
+            if (!emittedRuntime || !fileSystem.exists(runtimePath)) {
+                this.onRuntimeBundleFailure(new Error(`[HMR] Runtime bundle missing expected output at ${runtimePath}`));
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            this.onRuntimeBundleFailure(error);
+            return false;
+        }
+    }
+    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 = {}) {
+        const resolvedFilePath = path.resolve(filePath);
+        const isRegisteredDevTransformEdit = isRegisteredDevTransformEntrypoint(this.entrypointRegistry.getRegisteredEntrypoints(), resolvedFilePath);
+        if (!isRegisteredDevTransformEdit) {
+            this.invalidateDevTransformDependents(resolvedFilePath);
+        }
+        if (this.shouldSkipMissingFileChange(filePath) && !fileSystem.exists(filePath)) {
+            appLogger.debug(`[${this.constructor.name}] Skipping missing file change: ${filePath}`);
+            this.clearFailedEntrypointRegistration(filePath);
+            return;
+        }
+        if (isRegisteredDevTransformEdit) {
+            await this.prepareRegisteredEntrypointChange(resolvedFilePath);
+            const registered = this.entrypointRegistry.getRegisteredEntrypoints().get(resolvedFilePath);
+            if (registered && isDevTransformModuleUrl(registered.outputUrl)) {
+                this.devTransformServer.invalidateSource(resolvedFilePath);
+            }
+        }
+        const strategy = this.selectChangeStrategy(filePath);
+        if (!strategy) {
+            appLogger.warn(`[HMR] No strategy found for ${filePath}`);
+            this.broadcastStrategyAction(filePath, { type: 'none' }, options, !isRegisteredDevTransformEdit);
+            return;
+        }
+        appLogger.debug(`[${this.constructor.name}] Selected strategy: ${strategy.constructor.name}`);
+        this.broadcastStrategyAction(filePath, await strategy.process(filePath), options, !isRegisteredDevTransformEdit);
+    }
+    broadcastStrategyAction(filePath, action, options, fallbackReload) {
+        const shouldBroadcast = options.broadcast ?? true;
+        if (!shouldBroadcast) {
+            return;
+        }
+        if (action.type === 'broadcast' && action.events) {
+            if (this.bridge.subscriberCount === 0) {
+                appLogger.debug(`[${this.constructor.name}] Deferring HMR client broadcast for ${filePath} until a subscriber connects`);
+                return;
+            }
+            for (const event of action.events) {
+                const graphIdentities = event.graphIdentities ?? options.graphIdentities;
+                this.broadcast(graphIdentities === undefined ? event : { ...event, graphIdentities });
+            }
+            return;
+        }
+        if (fallbackReload && this.bridge.subscriberCount > 0) {
+            this.broadcast({ type: 'reload' });
+        }
+    }
+    invalidateDevTransformDependents(changedFilePath) {
+        const affectedEntrypoints = this.entrypointDependencyGraph.getDependencyEntrypoints(changedFilePath);
+        if (affectedEntrypoints.size > 0) {
+            for (const entrypointPath of affectedEntrypoints) {
+                this.devTransformServer.invalidateSource(entrypointPath);
+            }
+            this.devTransformServer.invalidateSource(changedFilePath);
+            return;
+        }
+        if (!this.entrypointDependencyGraph.supportsSelectiveInvalidation()) {
+            for (const sourcePath of this.entrypointRegistry.getRegisteredEntrypoints().keys()) {
+                this.devTransformServer.invalidateSource(sourcePath);
+            }
+            return;
+        }
+        this.devTransformServer.invalidateSource(changedFilePath);
+    }
+    consumeRegisteredScriptReloadRequired(filePath) {
+        const resolved = path.resolve(filePath);
+        const required = this.registeredScriptReloadRequired.has(resolved);
+        this.registeredScriptReloadRequired.delete(resolved);
+        return required;
+    }
+    getStrategiesByPriority() {
+        return [...this.strategies].sort((left, right) => right.priority - left.priority);
+    }
+    selectChangeStrategy(filePath) {
+        return this.getStrategiesByPriority().find((candidate) => {
+            try {
+                return candidate.matches(filePath);
+            }
+            catch (error) {
+                appLogger.error(error);
+                return false;
+            }
+        });
+    }
+    async prepareRegisteredEntrypointChange(filePath) {
+        const isRegisteredScript = isRegisteredScriptEntrypoint(this.entrypointRegistry.getRegisteredEntrypoints(), filePath);
+        if (!isRegisteredScript) {
+            this.invalidationService.invalidateServerModules([filePath]);
+        }
+        const handlers = this.appConfig.runtime?.registeredScriptEntrypointChangeHandlers ?? [];
+        for (const handler of handlers) {
+            try {
+                const result = await handler(filePath);
+                if (result === true) {
+                    this.registeredScriptReloadRequired.add(path.resolve(filePath));
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error
+                    ? error.message
+                    : `Failed to handle registered script entrypoint change for ${filePath}: ${String(error)}`;
+                this.broadcast({ type: 'error', message });
+                throw error;
+            }
+        }
+        if (isRegisteredScript) {
+            return;
+        }
+        const appModuleLoader = this.appConfig.runtime?.appModuleLoader;
+        if (!appModuleLoader) {
+            return;
+        }
+        await appModuleLoader.importModule({
+            filePath,
+            rootDir: this.appConfig.rootDir,
+            outdir: path.join(resolveInternalExecutionDir(this.appConfig), '.server-modules'),
+            externalPackages: true,
+            bypassCache: true,
+        });
+    }
+    getOutputUrl(entrypointPath) {
+        return this.entrypointRegistry.getRegisteredEntrypoints().get(path.resolve(entrypointPath))?.outputUrl;
+    }
+    /**
+     * Returns the registered script output when the entrypoint is already tracked for HMR.
+     *
+     * @remarks
+     * Dev-transform scripts use the source path as `outputPath`. A fresh dev session must
+     * still register the entrypoint so file watchers can invalidate it on change.
+     */
+    getResolvedScriptOutput(entrypointPath) {
+        const normalizedEntrypoint = path.resolve(entrypointPath);
+        const registered = this.entrypointRegistry.getRegisteredEntrypoints().get(normalizedEntrypoint);
+        if (!registered || !fileSystem.exists(registered.outputPath)) {
+            return undefined;
+        }
+        return registered;
+    }
+    getWatchedFiles() {
+        return this.entrypointRegistry.getWatchedOutputUrls();
+    }
+    getRegisteredEntrypoints() {
+        return this.entrypointRegistry.getRegisteredEntrypoints();
+    }
+    async tryHandleDevClientRequest(request) {
+        return this.devTransformServer.tryHandleRequest(request);
+    }
+    tryHandleAssetRequest(request) {
+        const url = new URL(request.url);
+        if (url.pathname === HMR_RUNTIME_SCRIPT_URL) {
+            const runtimePath = this.getRuntimePath();
+            if (fileSystem.exists(runtimePath)) {
+                return new Response(fileSystem.readFileAsBuffer(runtimePath), {
+                    headers: {
+                        'Content-Type': 'application/javascript',
+                        'Cache-Control': 'no-store, must-revalidate',
+                    },
+                });
+            }
+        }
+        if (url.pathname === DEV_TOOLBAR_RUNTIME_SCRIPT_URL && this.shouldBuildDevToolbar()) {
+            const runtimeResponse = this.getDevToolbarHost().readBundledRuntime(this.devToolbarWorkDir);
+            if (runtimeResponse) {
+                return runtimeResponse;
+            }
+        }
+        return null;
+    }
+    getRuntimeWorkDir() {
+        return this.runtimeWorkDir;
+    }
+    getDefaultContext() {
+        return {
+            getWatchedFiles: () => this.entrypointRegistry.getWatchedOutputUrls(),
+            getRegisteredEntrypoints: () => this.entrypointRegistry.getRegisteredEntrypoints(),
+            getSrcDir: () => this.appConfig.absolutePaths.srcDir,
+            getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
+            getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
+            getEntrypointDependencyGraph: () => this.entrypointDependencyGraph,
+            importServerModule: async (filePath) => await this.serverModuleTranspiler.importModule({
+                filePath,
+                outdir: path.join(resolveInternalExecutionDir(this.appConfig), '.server-modules'),
+                externalPackages: true,
+            }),
+        };
+    }
+    stop() {
+        this.runtimeReady = false;
+        this.entrypointRegistry.clearAll();
+        this.devTransformServer.reset();
+        for (const watcher of this.watchers.values()) {
+            watcher.close();
+        }
+        this.watchers.clear();
+        this.entrypointDependencyGraph.reset();
+    }
+    clearFailedEntrypointRegistration(entrypointPath) {
+        this.entrypointRegistry.clearRegistration(entrypointPath);
+        this.entrypointDependencyGraph.clearEntrypointDependencies(entrypointPath);
+    }
+    async registerEntrypoint(entrypointPath) {
+        return this.registerDevTransformEntrypoint(entrypointPath, 'page').outputUrl;
+    }
+    async registerScriptEntrypoint(entrypointPath) {
+        const { normalized, outputUrl, role } = this.registerDevTransformEntrypoint(entrypointPath, 'script');
+        return {
+            sourcePath: normalized,
+            outputPath: normalized,
+            outputUrl,
+            role,
+        };
+    }
+    registerDevTransformEntrypoint(entrypointPath, role) {
+        const normalized = path.resolve(entrypointPath);
+        if (!fileSystem.exists(normalized)) {
+            throw new Error(`[HMR] Failed to register ${role} entrypoint: missing source ${normalized}`);
         }
-      }
+        const outputUrl = this.devTransformServer.registerModule(entrypointPath);
+        this.entrypointRegistry.registerTransformModule(entrypointPath, outputUrl, { role });
+        return { normalized, outputUrl, role };
     }
-    const entrypointDependencies = buildResult.dependencyGraph?.entrypoints?.[entrypointPath];
-    if (entrypointDependencies) {
-      this.entrypointDependencyGraph.setEntrypointDependencies(entrypointPath, entrypointDependencies);
+    [Symbol.dispose]() {
+        this.stop();
     }
-  }
-  [Symbol.dispose]() {
-    this.stop();
-  }
 }
-export {
-  SharedHmrManager
-};