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

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

@@ -2,7 +2,11 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { RESOLVED_ASSETS_DIR } from "../../config/constants.js";
-import { resolveHmrEntrypointOutputPaths } from "../../hmr/hmr-entrypoint-output.js";
+import {
+  removeStaleHmrEntrypointOutput,
+  isRegisteredScriptEntrypoint,
+  isBrowserOnlyRegisteredScriptEntrypoint
+} 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";
@@ -19,52 +23,31 @@ 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;
   watchers = /* @__PURE__ */ new Map();
-  watchedFiles = /* @__PURE__ */ new Map();
-  entrypointRegistrations = /* @__PURE__ */ new Map();
   distDir;
-  plugins = [];
   enabled = false;
   strategies = [];
   entrypointRegistrar;
   browserBundleService;
+  invalidationService;
   entrypointDependencyGraph;
   serverModuleTranspiler;
   runtimeBuildPromise = null;
-  constructor({ appConfig, bridge, registrationTimeoutMs }) {
+  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,
-      entrypointRegistrations: this.entrypointRegistrations,
-      watchedFiles: this.watchedFiles,
-      clearFailedRegistration: (entrypointPath) => this.clearFailedEntrypointRegistration(entrypointPath),
-      registrationTimeoutMs: resolveHmrRegistrationTimeoutMs(registrationTimeoutMs)
+      clearFailedRegistration: (entrypointPath) => this.clearFailedEntrypointRegistration(entrypointPath)
     });
     this.browserBundleService = new BrowserBundleService(appConfig);
+    this.invalidationService = new DevelopmentInvalidationService(appConfig);
     this.entrypointDependencyGraph = this.createEntrypointDependencyGraph(
       getAppEntrypointDependencyGraph(appConfig)
     );
@@ -97,9 +80,8 @@ class SharedHmrManager {
   }
   initializeStrategies() {
     const jsContext = {
-      getWatchedFiles: () => this.watchedFiles,
+      getWatchedFiles: () => this.entrypointRegistrar.getWatchedFiles(),
       getDistDir: () => this.distDir,
-      getPlugins: () => this.plugins,
       getSrcDir: () => this.appConfig.absolutePaths.srcDir,
       getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
       getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
@@ -118,9 +100,6 @@ class SharedHmrManager {
   registerStrategy(strategy) {
     this.strategies.push(strategy);
   }
-  setPlugins(plugins) {
-    this.plugins = [...plugins];
-  }
   setEnabled(enabled) {
     this.enabled = enabled;
   }
@@ -128,13 +107,13 @@ class SharedHmrManager {
     return this.enabled;
   }
   isRuntimeReady() {
-    return fileSystem.exists(this.getRuntimePath());
+    return this.runtimeReady && fileSystem.exists(this.getRuntimePath());
   }
   /**
-   * Builds the browser HMR runtime once and reuses the in-flight build for concurrent callers.
+   * Builds the browser HMR runtime once per manager session and reuses the in-flight build for concurrent callers.
    */
   async ensureRuntimeReady() {
-    if (this.isRuntimeReady()) {
+    if (this.runtimeReady) {
       return true;
     }
     if (this.runtimeBuildPromise) {
@@ -142,7 +121,9 @@ class SharedHmrManager {
     }
     this.runtimeBuildPromise = this.buildRuntimeInternal();
     try {
-      return await this.runtimeBuildPromise;
+      const ready = await this.runtimeBuildPromise;
+      this.runtimeReady = ready;
+      return ready;
     } finally {
       this.runtimeBuildPromise = null;
     }
@@ -155,44 +136,35 @@ class SharedHmrManager {
   }
   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,
-        plugins: this.plugins
+        minify: false
       });
       if (!result.success) {
         this.onRuntimeBundleFailure(result.logs);
         return false;
       }
-      this.syncRuntimeOutput(result);
-      return this.isRuntimeReady();
+      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;
     }
   }
-  /**
-   * @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(
       `[HMR] Broadcasting ${event.type} event, path=${event.path || "all"}, subscribers=${this.bridge.subscriberCount}`
@@ -200,20 +172,16 @@ class SharedHmrManager {
     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;
     }
-    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 (isRegisteredScriptEntrypoint(this.entrypointRegistrar.getRegistered(), resolvedFilePath)) {
+      await this.prepareRegisteredScriptChange(resolvedFilePath);
+    }
+    const strategy = this.selectChangeStrategy(filePath);
     if (!strategy) {
       appLogger.warn(`[HMR] No strategy found for ${filePath}`);
       return;
@@ -227,8 +195,92 @@ class SharedHmrManager {
       }
     }
   }
+  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);
+        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.watchedFiles.get(entrypointPath);
+    return this.entrypointRegistrar.getRegistered().get(path.resolve(entrypointPath))?.outputUrl;
   }
   /**
    * Returns the emitted HMR script output when the entrypoint is already registered
@@ -240,34 +292,22 @@ class SharedHmrManager {
    */
   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)) {
+    const registered = this.entrypointRegistrar.getRegistered().get(normalizedEntrypoint);
+    if (!registered || !fileSystem.exists(registered.outputPath)) {
       return void 0;
     }
-    const outputUrl = this.watchedFiles.get(normalizedEntrypoint) ?? derivedOutputUrl;
-    return { outputUrl, outputPath };
+    return registered;
   }
   getWatchedFiles() {
-    return this.watchedFiles;
+    return this.entrypointRegistrar.getWatchedFiles();
   }
   getDistDir() {
     return this.distDir;
   }
-  getPlugins() {
-    return this.plugins;
-  }
   getDefaultContext() {
     return {
-      getWatchedFiles: () => this.watchedFiles,
+      getWatchedFiles: () => this.entrypointRegistrar.getWatchedFiles(),
       getDistDir: () => this.distDir,
-      getPlugins: () => this.plugins,
       getSrcDir: () => this.appConfig.absolutePaths.srcDir,
       getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
       getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
@@ -281,27 +321,34 @@ class SharedHmrManager {
       })
     };
   }
+  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.watchedFiles.delete(entrypointPath);
+    this.entrypointRegistrar.clearRegistration(entrypointPath);
     this.entrypointDependencyGraph.clearEntrypointDependencies(entrypointPath);
   }
   async registerEntrypoint(entrypointPath) {
-    return await this.entrypointRegistrar.registerEntrypoint(entrypointPath, {
-      emit: async (normalizedEntrypoint) => await this.emitStrictEntrypoint(normalizedEntrypoint),
+    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) => new Error(`[HMR] Failed to register script entrypoint: ${normalizedEntrypoint}`)
+      getMissingOutputError: (normalizedEntrypoint, outputPath) => new Error(`[HMR] Failed to register script entrypoint: ${normalizedEntrypoint} to ${outputPath}`)
     });
   }
-  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({
@@ -309,12 +356,12 @@ class SharedHmrManager {
       entrypoints: [entrypointPath],
       outdir: this.distDir,
       naming,
-      minify: false,
-      plugins: this.plugins
+      minify: false
     });
     if (!buildResult.success) {
-      appLogger.error(`[HMR] Generic script entrypoint build failed for ${entrypointPath}:`, buildResult.logs);
-      return;
+      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);
@@ -331,21 +378,10 @@ class SharedHmrManager {
       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 = [];
-  }
   [Symbol.dispose]() {
     this.stop();
   }
 }
 export {
-  SharedHmrManager,
-  resolveHmrRegistrationTimeoutMs
+  SharedHmrManager
 };

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

@@ -1,10 +1,9 @@
 import type { EcoBuildPlugin } from './build-types.js';
 import type { AppBuildManifest } from './build-manifest.js';
-import type { EcoPagesAppConfig, IHmrManager } from '../types/internal-types.js';
+import type { EcoPagesAppConfig } 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

@@ -71,9 +71,6 @@ async function setupAppRuntimePlugins(options) {
     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);

package/src/hmr/hmr-entrypoint-output.d.ts

@@ -1,11 +1,26 @@
+/**
+ * Verified HMR entrypoint artifact produced by registration.
+ */
+export interface ResolvedHmrEntrypoint {
+    sourcePath: string;
+    outputPath: string;
+    outputUrl: string;
+}
 /**
  * Returns whether a source path is a registered client script HMR entrypoint.
+ */
+export declare function isRegisteredScriptEntrypoint(registered: ReadonlyMap<string, unknown>, filePath: string): boolean;
+/**
+ * Returns whether a registered script entrypoint is browser-only and must not be
+ * server-imported during HMR invalidation.
  *
  * @remarks
- * Registration comes from `dependencies.scripts` via `FileScriptProcessor`,
- * not from filename conventions such as `.script.tsx`.
+ * Declared `*.script.ts` modules run only in the browser bundle. Re-importing them
+ * on the server during `prepareRegisteredScriptChange()` executes DOM globals and
+ * aborts the watcher before the client artifact rebuilds. Radiant `*.script.tsx`
+ * entrypoints are server-rendered and remain on the invalidation path.
  */
-export declare function isRegisteredScriptEntrypoint(watchedFiles: ReadonlyMap<string, string>, filePath: string): boolean;
+export declare function isBrowserOnlyRegisteredScriptEntrypoint(filePath: string): boolean;
 export declare function encodeHmrDynamicSegments(filepath: string): string;
 /**
  * Resolves the on-disk and browser URL targets for one HMR script entrypoint.
@@ -26,3 +41,9 @@ export declare function removeStaleHmrEntrypointOutput(outputPath: string, scope
  * fresher artifact than the edited source file.
  */
 export declare function isHmrOutputFresh(outputPath: string, sourcePath: string): boolean;
+/**
+ * @remarks
+ * Missing output is treated as a benign rebuild race. This helper isolates the
+ * post-build case where a bundle exists but is still older than its source.
+ */
+export declare function isHmrOutputOlderThanSource(outputPath: string, sourcePath: string): boolean;

package/src/hmr/hmr-entrypoint-output.js

@@ -3,17 +3,11 @@ import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
 import { RESOLVED_ASSETS_DIR } from "../config/constants.js";
 import { appLogger } from "../global/app-logger.js";
-function isRegisteredScriptEntrypoint(watchedFiles, filePath) {
-  const resolvedPath = path.resolve(filePath);
-  if (watchedFiles.has(resolvedPath)) {
-    return true;
-  }
-  for (const entrypointPath of watchedFiles.keys()) {
-    if (path.resolve(entrypointPath) === resolvedPath) {
-      return true;
-    }
-  }
-  return false;
+function isRegisteredScriptEntrypoint(registered, filePath) {
+  return registered.has(path.resolve(filePath));
+}
+function isBrowserOnlyRegisteredScriptEntrypoint(filePath) {
+  return /\.script\.ts$/u.test(path.resolve(filePath));
 }
 function encodeHmrDynamicSegments(filepath) {
   return filepath.replace(/\[([^\]]+)\]/g, "_$1_");
@@ -49,9 +43,17 @@ function isHmrOutputFresh(outputPath, sourcePath) {
   const sourceMtimeMs = fs.statSync(sourcePath).mtimeMs;
   return outputMtimeMs >= sourceMtimeMs;
 }
+function isHmrOutputOlderThanSource(outputPath, sourcePath) {
+  if (!fileSystem.exists(outputPath) || !fileSystem.exists(sourcePath)) {
+    return false;
+  }
+  return fs.statSync(outputPath).mtimeMs < fs.statSync(sourcePath).mtimeMs;
+}
 export {
   encodeHmrDynamicSegments,
+  isBrowserOnlyRegisteredScriptEntrypoint,
   isHmrOutputFresh,
+  isHmrOutputOlderThanSource,
   isRegisteredScriptEntrypoint,
   removeStaleHmrEntrypointOutput,
   resolveHmrEntrypointOutputPaths

package/src/hmr/hmr-strategy.d.ts

@@ -133,6 +133,21 @@ export declare abstract class HmrStrategy {
      * ```
      */
     abstract matches(filePath: string): boolean;
+    /**
+     * Returns whether this strategy owns cold registration for the entrypoint.
+     *
+     * @remarks
+     * Registration dispatch uses only integration strategies that claim the
+     * entrypoint. File-change dispatch continues to use {@link matches}.
+     */
+    canEmitEntrypoint(_entrypointPath: string): boolean;
+    /**
+     * Materializes one integration-owned HMR entrypoint during registration.
+     *
+     * @remarks
+     * Must write the canonical output path and must not broadcast client events.
+     */
+    emitEntrypoint(_entrypointPath: string, _outputPath: string): Promise<void>;
     /**
      * Processes a file change and returns the action to take.
      *

package/src/hmr/hmr-strategy.js

@@ -37,6 +37,25 @@ class HmrStrategy {
   get priority() {
     return this.type + this.priorityOffset;
   }
+  /**
+   * Returns whether this strategy owns cold registration for the entrypoint.
+   *
+   * @remarks
+   * Registration dispatch uses only integration strategies that claim the
+   * entrypoint. File-change dispatch continues to use {@link matches}.
+   */
+  canEmitEntrypoint(_entrypointPath) {
+    return false;
+  }
+  /**
+   * Materializes one integration-owned HMR entrypoint during registration.
+   *
+   * @remarks
+   * Must write the canonical output path and must not broadcast client events.
+   */
+  async emitEntrypoint(_entrypointPath, _outputPath) {
+    return;
+  }
 }
 export {
   HmrStrategy,

package/src/hmr/strategies/js-hmr-strategy.d.ts

@@ -8,7 +8,6 @@
  * @module
  */
 import { HmrStrategy, type HmrAction } from '../hmr-strategy.js';
-import type { EcoBuildPlugin } from '../../build/build-types.js';
 import type { BrowserBundleExecutor } from '../../services/assets/browser-bundle.service.js';
 import type { EntrypointDependencyGraph } from '../../services/runtime-state/entrypoint-dependency-graph.service.js';
 /**
@@ -25,10 +24,6 @@ export interface JsHmrContext {
      * Directory where HMR bundles are written.
      */
     getDistDir(): string;
-    /**
-     * Build plugins to use during bundling.
-     */
-    getPlugins(): EcoBuildPlugin[];
     /**
      * Absolute path to the source directory.
      */

package/src/hmr/strategies/js-hmr-strategy.js

@@ -6,7 +6,8 @@ import {
   removeStaleHmrEntrypointOutput,
   resolveHmrEntrypointOutputPaths,
   isRegisteredScriptEntrypoint,
-  isHmrOutputFresh
+  isHmrOutputFresh,
+  isHmrOutputOlderThanSource
 } from "../hmr-entrypoint-output.js";
 class JsHmrStrategy extends HmrStrategy {
   type = HmrStrategyType.SCRIPT;
@@ -151,7 +152,6 @@ class JsHmrStrategy extends HmrStrategy {
           entrypoints: [entrypoint],
           outdir: this.context.getDistDir(),
           naming,
-          plugins: this.context.getPlugins(),
           minify: false
         });
         if (!result2.success) {
@@ -172,7 +172,6 @@ class JsHmrStrategy extends HmrStrategy {
         outdir: this.context.getDistDir(),
         outbase: this.context.getSrcDir(),
         naming: "[dir]/[name]",
-        plugins: this.context.getPlugins(),
         minify: false
       });
       if (!result.success) {
@@ -202,7 +201,11 @@ class JsHmrStrategy extends HmrStrategy {
   async processOutput(filepath, url, sourcePath) {
     try {
       if (sourcePath && !isHmrOutputFresh(filepath, sourcePath)) {
-        appLogger.warn(`[JsHmrStrategy] Skipping broadcast for stale HMR output ${url}`);
+        if (isHmrOutputOlderThanSource(filepath, sourcePath)) {
+          appLogger.warn(
+            `[JsHmrStrategy] HMR output is older than source after rebuild; skipping broadcast for ${url}`
+          );
+        }
         return { success: false, requiresReload: false };
       }
       const code = await fileSystem.readFile(filepath);

package/src/services/assets/asset-processing-service/processors/script/file-script.processor.d.ts

@@ -3,7 +3,6 @@ import type { FileScriptAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseScriptProcessor } from '../base/base-script-processor.js';
 export declare class FileScriptProcessor extends BaseScriptProcessor<FileScriptAsset> {
     private hmrManager?;
-    private resolveHmrOutputFilepath;
     setHmrManager(hmrManager: IHmrManager): void;
     process(dep: FileScriptAsset): Promise<ProcessedAsset>;
 }