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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/core",
-  "version": "0.2.0-beta.20",
+  "version": "0.2.0-beta.21",
   "description": "Core package for Ecopages",
   "keywords": [
     "ecopages",
@@ -17,7 +17,7 @@
     "directory": "packages/core"
   },
   "dependencies": {
-    "@ecopages/file-system": "0.2.0-beta.20",
+    "@ecopages/file-system": "0.2.0-beta.21",
     "@ecopages/logger": "^0.2.3",
     "@ecopages/scripts-injector": "^0.1.5",
     "@oxc-project/runtime": "0.134.0",

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

@@ -7,7 +7,6 @@ type BunSocketHandler = WebSocketHandler<unknown>;
 export interface HmrManagerParams {
     appConfig: EcoPagesAppConfig;
     bridge: ClientBridge;
-    registrationTimeoutMs?: number;
 }
 /**
  * Bun development HMR manager.
@@ -27,7 +26,7 @@ export declare class HmrManager extends SharedHmrManager {
      * generation to `SharedHmrManager`. The Bun subclass only supplies the
      * transport-specific dependency graph policy and websocket hook surface.
      */
-    constructor({ appConfig, bridge, registrationTimeoutMs }: HmrManagerParams);
+    constructor({ appConfig, bridge }: HmrManagerParams);
     /**
      * Reuses the shared in-memory dependency graph when possible and otherwise
      * creates the Bun-compatible default graph implementation.

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

@@ -13,8 +13,8 @@ class HmrManager extends SharedHmrManager {
    * generation to `SharedHmrManager`. The Bun subclass only supplies the
    * transport-specific dependency graph policy and websocket hook surface.
    */
-  constructor({ appConfig, bridge, registrationTimeoutMs }) {
-    super({ appConfig, bridge, registrationTimeoutMs });
+  constructor({ appConfig, bridge }) {
+    super({ appConfig, bridge });
   }
   /**
    * Reuses the shared in-memory dependency graph when possible and otherwise

package/src/adapters/bun/server-adapter.js

@@ -17,10 +17,10 @@ import { createBunUserWebSocketLifecycle } from "../shared/bun-user-websocket-li
 import { createEcopagesSocket } from "../shared/websocket-lifecycle.js";
 import { resolveServeRuntimeOrigin } from "../shared/runtime-app-bootstrap.js";
 import {
+  attachHmrToIntegrations,
   disposeDevResources,
   maybeInjectAdapterHmrHtmlResponse,
-  prepareRuntimePublicDir,
-  wireIntegrationHmrManagers
+  prepareRuntimePublicDir
 } from "../shared/runtime-server-lifecycle.js";
 import { ClientBridge } from "./client-bridge.js";
 import { setAppDevClientBridge } from "../../dev/client-bridge-registry.js";
@@ -193,12 +193,13 @@ class BunServerAdapter extends SharedServerAdapter {
       await setupAppRuntimePlugins({
         appConfig: this.appConfig,
         runtimeOrigin: this.runtimeOrigin,
-        hmrManager: this.hmrManager,
         onRuntimePlugin: (plugin) => {
           this.registerBunRuntimePlugin(plugin);
         }
       });
-      wireIntegrationHmrManagers(this.appConfig, this.hmrManager);
+      if (options?.watch) {
+        attachHmrToIntegrations(this.appConfig, this.hmrManager);
+      }
     } catch (error) {
       appLogger.error(`Failed to initialize plugins: ${error instanceof Error ? error.message : String(error)}`);
       throw error;

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

@@ -4,7 +4,6 @@ import { SharedHmrManager } from '../shared/shared-hmr-manager.js';
 export interface NodeHmrManagerParams {
     appConfig: EcoPagesAppConfig;
     bridge: IClientBridge;
-    registrationTimeoutMs?: number;
 }
 /**
  * Node development HMR manager.
@@ -29,7 +28,7 @@ export declare class NodeHmrManager extends SharedHmrManager {
      * actually differs: dependency-graph storage, missing-file tolerance, and how
      * runtime bundle failures disable HMR.
      */
-    constructor({ appConfig, bridge, registrationTimeoutMs }: NodeHmrManagerParams);
+    constructor({ appConfig, bridge }: NodeHmrManagerParams);
     /**
      * Reuses the shared in-memory dependency graph when the app already has one and
      * otherwise creates the default Node development graph.

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

@@ -13,8 +13,8 @@ class NodeHmrManager extends SharedHmrManager {
    * actually differs: dependency-graph storage, missing-file tolerance, and how
    * runtime bundle failures disable HMR.
    */
-  constructor({ appConfig, bridge, registrationTimeoutMs }) {
-    super({ appConfig, bridge, registrationTimeoutMs });
+  constructor({ appConfig, bridge }) {
+    super({ appConfig, bridge });
   }
   /**
    * Reuses the shared in-memory dependency graph when the app already has one and

package/src/adapters/node/server-adapter.js

@@ -15,10 +15,10 @@ import { SharedServerAdapter } from "../shared/server-adapter.js";
 import { ServerStaticBuilder } from "../shared/server-static-builder.js";
 import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../config/constants.js";
 import {
+  attachHmrToIntegrations,
+  disposeDevResources,
   maybeInjectAdapterHmrHtmlResponse,
-  prepareRuntimePublicDir,
-  wireIntegrationHmrManagers,
-  disposeDevResources
+  prepareRuntimePublicDir
 } from "../shared/runtime-server-lifecycle.js";
 import { resolveServeRuntimeOrigin } from "../shared/runtime-app-bootstrap.js";
 import { NodeClientAbortError, NodeHttpRequestBridge } from "./http-request-bridge.js";
@@ -119,8 +119,7 @@ class NodeServerAdapter extends SharedServerAdapter {
     if (!this.deferRuntimeAssetSetup) {
       await setupAppRuntimePlugins({
         appConfig: this.appConfig,
-        runtimeOrigin: this.runtimeOrigin,
-        hmrManager: this.hmrManager ?? void 0
+        runtimeOrigin: this.runtimeOrigin
       });
     }
     await this.initializeSharedRouteHandling({
@@ -298,7 +297,7 @@ class NodeServerAdapter extends SharedServerAdapter {
           }
         });
       }
-      wireIntegrationHmrManagers(this.appConfig, this.hmrManager);
+      attachHmrToIntegrations(this.appConfig, this.hmrManager);
       this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
       const watcher = new ProjectWatcher({
         config: this.appConfig,

package/src/adapters/shared/hmr-entrypoint-registrar.d.ts

@@ -1,20 +1,4 @@
-/**
- * Shared runtime state used while registering HMR-owned entrypoints.
- */
-export interface HmrEntrypointRegistrarOptions {
-    /** Absolute source directory used to derive the emitted HMR path. */
-    srcDir: string;
-    /** Absolute distribution directory where HMR outputs are written. */
-    distDir: string;
-    /** In-flight registrations keyed by normalized absolute entrypoint path. */
-    entrypointRegistrations: Map<string, Promise<string>>;
-    /** Stable entrypoint-to-output mapping retained once an entrypoint is registered. */
-    watchedFiles: Map<string, string>;
-    /** Runtime-specific cleanup invoked when an entrypoint registration fails. */
-    clearFailedRegistration?: (entrypointPath: string) => void;
-    /** Development-only guardrail for integrations that never finish producing output. */
-    registrationTimeoutMs: number;
-}
+import { type ResolvedHmrEntrypoint } from '../../hmr/hmr-entrypoint-output.js';
 /**
  * Runtime-specific hooks required to materialize a single HMR entrypoint.
  */
@@ -28,26 +12,35 @@ export interface HmrEntrypointRegistrationOptions {
      */
     getMissingOutputError(entrypointPath: string, outputPath: string): Error;
 }
+export interface HmrEntrypointRegistrarOptions {
+    /** Absolute source directory used to derive the emitted HMR path. */
+    srcDir: string;
+    /** Absolute distribution directory where HMR outputs are written. */
+    distDir: string;
+    /** Runtime-specific cleanup invoked when an entrypoint registration fails. */
+    clearFailedRegistration?: (entrypointPath: string) => void;
+}
 /**
  * Coordinates the shared HMR entrypoint registration lifecycle for both Node and Bun managers.
  *
- * The registrar owns the cross-runtime policy: normalize entrypoint identities, dedupe concurrent
- * registrations, derive the emitted `_hmr` output path, clear stale output before rebuilding, and
- * apply the development timeout that prevents unresolved registrations from hanging navigation.
- * Runtime-specific managers remain responsible for the actual emit step and any cleanup outside
- * this shared registration flow.
+ * @remarks
+ * The registrar owns in-flight deduplication and the registered entrypoint table.
+ * A source path is committed only after emit succeeds and the expected output exists on disk.
  */
 export declare class HmrEntrypointRegistrar {
     private readonly options;
+    private readonly inFlight;
+    private readonly registered;
     constructor(options: HmrEntrypointRegistrarOptions);
+    getRegistered(): ReadonlyMap<string, ResolvedHmrEntrypoint>;
+    getWatchedFiles(): Map<string, string>;
+    clearRegistration(entrypointPath: string): void;
+    clearAll(): void;
     /**
-     * Registers a single source entrypoint and returns the browser URL for its emitted HMR module.
+     * Registers a single source entrypoint and returns its verified HMR artifact.
      *
-     * Concurrent requests for the same normalized entrypoint share the same in-flight promise so the
-     * integration only builds once per registration cycle.
+     * Concurrent requests for the same normalized entrypoint share the same in-flight promise.
      */
-    registerEntrypoint(entrypointPath: string, registrationOptions: HmrEntrypointRegistrationOptions): Promise<string>;
+    registerEntrypoint(entrypointPath: string, registrationOptions: HmrEntrypointRegistrationOptions): Promise<ResolvedHmrEntrypoint>;
     private registerEntrypointInternal;
-    private awaitEntrypointRegistration;
-    private getEntrypointOutput;
 }

package/src/adapters/shared/hmr-entrypoint-registrar.js

@@ -1,62 +1,80 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { removeStaleHmrEntrypointOutput, resolveHmrEntrypointOutputPaths } from "../../hmr/hmr-entrypoint-output.js";
+import {
+  removeStaleHmrEntrypointOutput,
+  resolveHmrEntrypointOutputPaths
+} from "../../hmr/hmr-entrypoint-output.js";
 class HmrEntrypointRegistrar {
   options;
+  inFlight = /* @__PURE__ */ new Map();
+  registered = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = options;
   }
+  getRegistered() {
+    return this.registered;
+  }
+  getWatchedFiles() {
+    const watchedFiles = /* @__PURE__ */ new Map();
+    for (const [sourcePath, entrypoint] of this.registered) {
+      watchedFiles.set(sourcePath, entrypoint.outputUrl);
+    }
+    return watchedFiles;
+  }
+  clearRegistration(entrypointPath) {
+    this.registered.delete(path.resolve(entrypointPath));
+  }
+  clearAll() {
+    this.inFlight.clear();
+    this.registered.clear();
+  }
   /**
-   * Registers a single source entrypoint and returns the browser URL for its emitted HMR module.
+   * Registers a single source entrypoint and returns its verified HMR artifact.
    *
-   * Concurrent requests for the same normalized entrypoint share the same in-flight promise so the
-   * integration only builds once per registration cycle.
+   * Concurrent requests for the same normalized entrypoint share the same in-flight promise.
    */
   async registerEntrypoint(entrypointPath, registrationOptions) {
     const normalizedEntrypoint = path.resolve(entrypointPath);
-    const existingRegistration = this.options.entrypointRegistrations.get(normalizedEntrypoint);
+    const existing = this.registered.get(normalizedEntrypoint);
+    if (existing && fileSystem.exists(existing.outputPath)) {
+      return existing;
+    }
+    const existingRegistration = this.inFlight.get(normalizedEntrypoint);
     if (existingRegistration) {
-      return await this.awaitEntrypointRegistration(existingRegistration, normalizedEntrypoint);
+      return await existingRegistration;
     }
     const registration = this.registerEntrypointInternal(normalizedEntrypoint, registrationOptions);
-    this.options.entrypointRegistrations.set(normalizedEntrypoint, registration);
+    this.inFlight.set(normalizedEntrypoint, registration);
     try {
-      return await this.awaitEntrypointRegistration(registration, normalizedEntrypoint);
+      return await registration;
     } catch (error) {
       this.options.clearFailedRegistration?.(normalizedEntrypoint);
+      this.registered.delete(normalizedEntrypoint);
       throw error;
     } finally {
-      this.options.entrypointRegistrations.delete(normalizedEntrypoint);
+      if (this.inFlight.get(normalizedEntrypoint) === registration) {
+        this.inFlight.delete(normalizedEntrypoint);
+      }
     }
   }
   async registerEntrypointInternal(entrypointPath, registrationOptions) {
-    if (this.options.watchedFiles.has(entrypointPath)) {
-      return this.options.watchedFiles.get(entrypointPath);
-    }
-    const { outputPath, outputUrl } = this.getEntrypointOutput(entrypointPath);
-    this.options.watchedFiles.set(entrypointPath, outputUrl);
+    const { outputPath, outputUrl } = resolveHmrEntrypointOutputPaths(
+      this.options.srcDir,
+      this.options.distDir,
+      entrypointPath
+    );
     removeStaleHmrEntrypointOutput(outputPath, "HMR");
     await registrationOptions.emit(entrypointPath, outputPath);
     if (!fileSystem.exists(outputPath)) {
       throw registrationOptions.getMissingOutputError(entrypointPath, outputPath);
     }
-    return outputUrl;
-  }
-  async awaitEntrypointRegistration(registration, entrypointPath) {
-    if (process.env.NODE_ENV !== "development") {
-      return await registration;
-    }
-    return await Promise.race([
-      registration,
-      new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`[HMR] Timed out registering entrypoint: ${entrypointPath}`));
-        }, this.options.registrationTimeoutMs);
-      })
-    ]);
-  }
-  getEntrypointOutput(entrypointPath) {
-    return resolveHmrEntrypointOutputPaths(this.options.srcDir, this.options.distDir, entrypointPath);
+    const resolved = {
+      sourcePath: entrypointPath,
+      outputPath,
+      outputUrl
+    };
+    this.registered.set(entrypointPath, resolved);
+    return resolved;
   }
 }
 export {

package/src/adapters/shared/runtime-server-lifecycle.d.ts

@@ -6,7 +6,15 @@ import type { ProjectWatcher } from '../../watchers/project-watcher.js';
  */
 export declare function prepareRuntimePublicDir(appConfig: EcoPagesAppConfig): void;
 /**
- * Propagates browser build plugins and the shared HMR manager into integrations.
+ * Attaches the shared HMR manager to every integration exactly once per app config.
+ *
+ * @remarks
+ * Runtime plugin setup must not call `integration.setHmrManager()` directly. Adapters invoke
+ * this after the manager is enabled so late plugin init cannot double-bind integrations.
+ */
+export declare function attachHmrToIntegrations(appConfig: EcoPagesAppConfig, hmrManager: IHmrManager): void;
+/**
+ * @deprecated Use {@link attachHmrToIntegrations} instead.
  */
 export declare function wireIntegrationHmrManagers(appConfig: EcoPagesAppConfig, hmrManager: IHmrManager): void;
 /**

package/src/adapters/shared/runtime-server-lifecycle.js

@@ -2,7 +2,6 @@ import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
 import { RESOLVED_ASSETS_DIR } from "../../config/constants.js";
 import { disposeAppBuildRuntime } from "../../build/build-runtime.js";
-import { getAppBrowserBuildPlugins } from "../../build/build-adapter.js";
 import { copyRuntimePublicDirIfChanged } from "./copy-runtime-public-dir.js";
 import { clearAppDevClientBridge } from "../../dev/client-bridge-registry.js";
 import { clearAppHmrManager } from "../../dev/hmr-manager-registry.js";
@@ -14,12 +13,19 @@ function prepareRuntimePublicDir(appConfig) {
   }
   fileSystem.ensureDir(path.join(appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR));
 }
-function wireIntegrationHmrManagers(appConfig, hmrManager) {
-  hmrManager.setPlugins(getAppBrowserBuildPlugins(appConfig));
+const attachedHmrApps = /* @__PURE__ */ new WeakSet();
+function attachHmrToIntegrations(appConfig, hmrManager) {
+  if (attachedHmrApps.has(appConfig)) {
+    return;
+  }
+  attachedHmrApps.add(appConfig);
   for (const integration of appConfig.integrations) {
     integration.setHmrManager(hmrManager);
   }
 }
+function wireIntegrationHmrManagers(appConfig, hmrManager) {
+  attachHmrToIntegrations(appConfig, hmrManager);
+}
 async function maybeInjectAdapterHmrHtmlResponse(response, options) {
   if (shouldInjectHmrHtmlResponse(options.watch, options.hmrManager, options.hostOwnsDevClient) && isHtmlResponse(response)) {
     return injectHmrRuntimeIntoHtmlResponse(response);
@@ -36,6 +42,7 @@ async function disposeDevResources(options) {
   await options.previewHost.stop();
 }
 export {
+  attachHmrToIntegrations,
   disposeDevResources,
   maybeInjectAdapterHmrHtmlResponse,
   prepareRuntimePublicDir,

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

@@ -3,6 +3,7 @@ import { fileSystem } from "@ecopages/file-system";
 import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../config/constants.js";
 import { appLogger } from "../../global/app-logger.js";
 import { build, getAppBuildAdapter, setupAppRuntimePlugins } from "../../build/build-adapter.js";
+import { attachHmrToIntegrations } from "./runtime-server-lifecycle.js";
 import { resolveBuildProfileOptions } from "../../build/build-profile-options.js";
 import {
   getServerBundleOutputPaths,
@@ -76,9 +77,11 @@ class ServerStaticBuilder {
       await setupAppRuntimePlugins({
         appConfig: this.appConfig,
         runtimeOrigin: this.runtimeOrigin,
-        hmrManager: this.hmrManager,
         onRuntimePlugin: this.onRuntimePlugin
       });
+      if (this.hmrManager?.isEnabled()) {
+        attachHmrToIntegrations(this.appConfig, this.hmrManager);
+      }
     } finally {
       appLogger.debugTimeEnd("refreshRuntimeAssets");
     }

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

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
+import { type ResolvedHmrEntrypoint } from '../../hmr/hmr-entrypoint-output.js';
 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 { DevelopmentInvalidationService } from '../../services/invalidation/development-invalidation.service.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';
@@ -10,28 +11,25 @@ import type { ServerModuleTranspiler } from '../../services/module-loading/serve
 type HandleFileChangeOptions = {
     broadcast?: boolean;
 };
-export declare function resolveHmrRegistrationTimeoutMs(explicitTimeoutMs?: number): number;
 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 invalidationService: DevelopmentInvalidationService;
     protected readonly entrypointDependencyGraph: EntrypointDependencyGraph;
     protected readonly serverModuleTranspiler: ServerModuleTranspiler;
     private runtimeBuildPromise;
-    constructor({ appConfig, bridge, registrationTimeoutMs }: SharedHmrManagerParams);
+    private runtimeReady;
+    constructor({ appConfig, bridge }: SharedHmrManagerParams);
     protected abstract createEntrypointDependencyGraph(existingEntrypointDependencyGraph: EntrypointDependencyGraph): EntrypointDependencyGraph;
     protected shouldSkipMissingFileChange(_filePath: string): boolean;
     protected onRuntimeBundleFailure(error: unknown): void;
@@ -39,26 +37,39 @@ export declare abstract class SharedHmrManager implements IHmrManager {
     protected shouldJsStrategyProcessEntrypoint(entrypointPath: string): boolean;
     protected initializeStrategies(): void;
     registerStrategy(strategy: HmrStrategy): void;
-    setPlugins(plugins: EcoBuildPlugin[]): void;
     setEnabled(enabled: boolean): void;
     isEnabled(): boolean;
     isRuntimeReady(): boolean;
     /**
-     * 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.
      */
     ensureRuntimeReady(): Promise<boolean>;
     buildRuntime(): Promise<void>;
     getRuntimePath(): string;
     private buildRuntimeInternal;
+    broadcast(event: ClientBridgeEvent): void;
+    handleFileChange(filePath: string, options?: HandleFileChangeOptions): Promise<void>;
+    private getStrategiesByPriority;
+    private selectChangeStrategy;
+    private selectEntrypointEmitter;
+    protected createUnownedEntrypointError(entrypointPath: string): Error;
     /**
+     * Materializes one integration-owned page entrypoint during cold registration.
+     *
      * @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/`.
+     * Registration uses {@link HmrStrategy.canEmitEntrypoint} / {@link HmrStrategy.emitEntrypoint},
+     * not {@link HmrStrategy.matches} / {@link HmrStrategy.process}. File-change handling stays
+     * on `handleFileChange()`.
      */
-    private syncRuntimeOutput;
-    broadcast(event: ClientBridgeEvent): void;
-    handleFileChange(filePath: string, options?: HandleFileChangeOptions): Promise<void>;
+    emitIntegrationEntrypoint(entrypointPath: string, outputPath: string): Promise<void>;
+    /**
+     * 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.
+     */
+    private prepareRegisteredScriptChange;
     getOutputUrl(entrypointPath: string): string | undefined;
     /**
      * Returns the emitted HMR script output when the entrypoint is already registered
@@ -68,20 +79,15 @@ export declare abstract class SharedHmrManager implements IHmrManager {
      * 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: string): {
-        outputUrl: string;
-        outputPath: string;
-    } | undefined;
+    getResolvedScriptOutput(entrypointPath: string): ResolvedHmrEntrypoint | undefined;
     getWatchedFiles(): Map<string, string>;
     getDistDir(): string;
-    getPlugins(): EcoBuildPlugin[];
     getDefaultContext(): DefaultHmrContext;
+    stop(): void;
     protected clearFailedEntrypointRegistration(entrypointPath: string): void;
     registerEntrypoint(entrypointPath: string): Promise<string>;
-    registerScriptEntrypoint(entrypointPath: string): Promise<string>;
-    protected emitStrictEntrypoint(entrypointPath: string): Promise<void>;
+    registerScriptEntrypoint(entrypointPath: string): Promise<ResolvedHmrEntrypoint>;
     protected emitScriptEntrypoint(entrypointPath: string, outputPath: string): Promise<void>;
-    stop(): void;
     [Symbol.dispose](): void;
 }
 export {};