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

package/src/adapters/shared/hmr/hmr-html-response.js

@@ -1,36 +1,50 @@
-const HMR_RUNTIME_IMPORT = "import '/_hmr_runtime.js'";
-const HMR_RUNTIME_SCRIPT = `<script type="module">${HMR_RUNTIME_IMPORT};<\/script>`;
-function isHtmlResponse(response) {
-  const contentType = response.headers.get("Content-Type");
-  return contentType !== null && contentType.startsWith("text/html");
+import { HMR_RUNTIME_SCRIPT_URL } from '../../../hmr/hmr-runtime-paths.js';
+const HMR_RUNTIME_IMPORT = `import '${HMR_RUNTIME_SCRIPT_URL}'`;
+const HMR_RUNTIME_SCRIPT = `<script type="module">${HMR_RUNTIME_IMPORT};</script>`;
+/**
+ * Returns whether a response is HTML and therefore eligible for development HMR
+ * runtime injection.
+ */
+export function isHtmlResponse(response) {
+    const contentType = response.headers.get('Content-Type');
+    return contentType !== null && contentType.startsWith('text/html');
 }
-function shouldInjectHmrHtmlResponse(watch, hmrManager, hostOwnsDevClient = false) {
-  if (hostOwnsDevClient) {
-    return false;
-  }
-  return watch && hmrManager?.isEnabled() === true;
+/**
+ * Returns whether HTML responses should receive the HMR runtime bootstrap.
+ *
+ * This is shared because filesystem page responses and adapter-level HTML
+ * responses flow through different layers, but both need identical injection
+ * behavior in watch mode.
+ */
+export function shouldInjectHmrHtmlResponse(watch, hmrManager, hostOwnsDevClient = false) {
+    if (hostOwnsDevClient) {
+        return false;
+    }
+    return watch && hmrManager?.isEnabled() === true;
 }
-async function injectHmrRuntimeIntoHtmlResponse(response) {
-  const html = await response.text();
-  const headers = new Headers(response.headers);
-  headers.set("Cache-Control", "no-store, must-revalidate");
-  headers.delete("Content-Length");
-  if (html.includes(HMR_RUNTIME_IMPORT)) {
-    return new Response(html, {
-      status: response.status,
-      statusText: response.statusText,
-      headers
+/**
+ * Injects the development HMR runtime script into an HTML response if it is not
+ * already present.
+ *
+ * The check is intentionally idempotent because an HTML response can pass
+ * through more than one development-layer wrapper before reaching the client.
+ */
+export async function injectHmrRuntimeIntoHtmlResponse(response) {
+    const html = await response.text();
+    const headers = new Headers(response.headers);
+    headers.set('Cache-Control', 'no-store, must-revalidate');
+    headers.delete('Content-Length');
+    if (html.includes(HMR_RUNTIME_IMPORT)) {
+        return new Response(html, {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+        });
+    }
+    const updatedHtml = html.replace(/<\/html>/i, `${HMR_RUNTIME_SCRIPT}</html>`);
+    return new Response(updatedHtml, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
     });
-  }
-  const updatedHtml = html.replace(/<\/html>/i, `${HMR_RUNTIME_SCRIPT}</html>`);
-  return new Response(updatedHtml, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
 }
-export {
-  injectHmrRuntimeIntoHtmlResponse,
-  isHtmlResponse,
-  shouldInjectHmrHtmlResponse
-};

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

@@ -4,10 +4,12 @@ import type { DefaultHmrContext, EcoPagesAppConfig, IHmrManager, IClientBridge }
 import { type HmrStrategy } from '../../../hmr/hmr-strategy.js';
 import { DevelopmentInvalidationService } from '../../../services/invalidation/development-invalidation.service.js';
 import type { ClientBridgeEvent, HmrFileChangeOptions } from '../../../types/public-types.js';
-import { HmrEntrypointRegistrar } from './hmr-entrypoint-registrar.js';
+import { DevTransformEntrypointRegistry } from './dev-transform-entrypoint-registry.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';
+import { DevTransformServer } from '../../../dev/transform-server/dev-transform-server.js';
+import type { DevTransformBundleContributor } from '../../../dev/transform-server/types.js';
 type HandleFileChangeOptions = HmrFileChangeOptions;
 type SharedHmrManagerParams = {
     appConfig: EcoPagesAppConfig;
@@ -17,22 +19,30 @@ export declare abstract class SharedHmrManager implements IHmrManager {
     readonly appConfig: EcoPagesAppConfig;
     protected readonly bridge: IClientBridge;
     protected watchers: Map<string, fs.FSWatcher>;
-    protected distDir: string;
+    protected runtimeWorkDir: string;
     protected enabled: boolean;
     protected strategies: HmrStrategy[];
-    protected readonly entrypointRegistrar: HmrEntrypointRegistrar;
+    private readonly registeredScriptReloadRequired;
+    protected readonly entrypointRegistry: DevTransformEntrypointRegistry;
     protected readonly browserBundleService: BrowserBundleService;
     protected readonly invalidationService: DevelopmentInvalidationService;
     protected readonly entrypointDependencyGraph: EntrypointDependencyGraph;
     protected readonly serverModuleTranspiler: ServerModuleTranspiler;
     private runtimeBuildPromise;
     private runtimeReady;
+    private devToolbarWorkDir;
+    private devToolbarBuildPromise;
+    private devToolbarReady;
+    protected readonly devTransformServer: DevTransformServer;
     constructor({ appConfig, bridge }: SharedHmrManagerParams);
     protected abstract createEntrypointDependencyGraph(existingEntrypointDependencyGraph: EntrypointDependencyGraph): EntrypointDependencyGraph;
     protected shouldSkipMissingFileChange(_filePath: string): boolean;
     protected onRuntimeBundleFailure(error: unknown): void;
-    protected ensureDistDir(): void;
+    protected ensureRuntimeWorkDir(): void;
+    protected shouldBuildDevToolbar(): boolean;
+    private getDevToolbarHost;
     protected shouldJsStrategyProcessEntrypoint(entrypointPath: string): boolean;
+    registerDevTransformContributor(contributor: DevTransformBundleContributor): void;
     protected initializeStrategies(): void;
     registerStrategy(strategy: HmrStrategy): void;
     setEnabled(enabled: boolean): void;
@@ -42,60 +52,41 @@ export declare abstract class SharedHmrManager implements IHmrManager {
      * Builds the browser HMR runtime once per manager session and reuses the in-flight build for concurrent callers.
      */
     ensureRuntimeReady(): Promise<boolean>;
+    private ensureHmrRuntimeReady;
+    private ensureDevToolbarRuntimeReady;
     buildRuntime(): Promise<void>;
     getRuntimePath(): string;
+    private buildDevToolbarRuntimeInternal;
+    getDevToolbarRuntimePath(): string;
     private buildRuntimeInternal;
     broadcast(event: ClientBridgeEvent): void;
     handleFileChange(filePath: string, options?: HandleFileChangeOptions): Promise<void>;
+    private broadcastStrategyAction;
+    private invalidateDevTransformDependents;
+    consumeRegisteredScriptReloadRequired(filePath: string): boolean;
     private getStrategiesByPriority;
     private selectChangeStrategy;
-    private selectEntrypointEmitter;
-    protected createUnownedEntrypointError(entrypointPath: string): Error;
-    /**
-     * 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()`.
-     */
-    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;
+    private prepareRegisteredEntrypointChange;
     getOutputUrl(entrypointPath: string): string | undefined;
     /**
-     * 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: ResolvedHmrEntrypoint): void;
-    /**
-     * Returns the emitted HMR script output when the entrypoint is already registered
-     * and its browser bundle exists on disk.
+     * Returns the registered script output when the entrypoint is already tracked for HMR.
      *
      * @remarks
-     * Disk artifacts alone are not enough: a fresh dev session must still register
-     * the entrypoint so file watchers can rebuild it on change.
+     * 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: string): ResolvedHmrEntrypoint | undefined;
     getWatchedFiles(): Map<string, string>;
+    getRegisteredEntrypoints(): ReadonlyMap<string, ResolvedHmrEntrypoint>;
+    tryHandleDevClientRequest(request: Request): Promise<Response | null>;
     tryHandleAssetRequest(request: Request): Response | null;
-    getDistDir(): string;
+    getRuntimeWorkDir(): string;
     getDefaultContext(): DefaultHmrContext;
     stop(): void;
     protected clearFailedEntrypointRegistration(entrypointPath: string): void;
     registerEntrypoint(entrypointPath: string): Promise<string>;
     registerScriptEntrypoint(entrypointPath: string): Promise<ResolvedHmrEntrypoint>;
-    protected emitScriptEntrypoint(entrypointPath: string, outputPath: string): Promise<void>;
+    private registerDevTransformEntrypoint;
     [Symbol.dispose](): void;
 }
 export {};