@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/adapters/shared/render-context.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createRenderContext } from './render-context.ts';
+import type { IntegrationPlugin } from '../../plugins/integration-plugin.ts';
+import type { IntegrationRenderer } from '../../route-renderer/orchestration/integration-renderer.ts';
+import type { EcoFunctionComponent } from '../../public-types.ts';
+
+describe('createRenderContext', () => {
+	const RenderToResponse = vi.fn(() => Promise.resolve(new Response('rendered')));
+
+	const Renderer = {
+		name: '-renderer',
+		renderToResponse: RenderToResponse,
+	} as unknown as IntegrationRenderer;
+
+	const ExplicitRenderer = {
+		name: 'explicit-renderer',
+		renderToResponse: RenderToResponse,
+	} as unknown as IntegrationRenderer;
+
+	const InitializeRenderer = vi.fn(() => Renderer);
+
+	const Plugin = {
+		name: '-integration',
+		initializeRenderer: InitializeRenderer,
+	} as unknown as IntegrationPlugin;
+
+	const ExplicitInitializeRenderer = vi.fn(() => ExplicitRenderer);
+
+	const ExplicitPlugin = {
+		name: 'explicit-renderer',
+		initializeRenderer: ExplicitInitializeRenderer,
+	} as unknown as IntegrationPlugin;
+
+	const ViewFn = ((props: { foo: string }) => `<div>${props.foo}</div>`) as EcoFunctionComponent<
+		{ foo: string },
+		string
+	>;
+	ViewFn.config = {
+		__eco: {
+			id: 'test',
+			file: '/some/dir/-view.ts',
+			integration: '-integration',
+		},
+	};
+
+	const renderContext = createRenderContext({
+		integrations: [Plugin, ExplicitPlugin],
+	});
+
+	it('should create a render context with methods', () => {
+		expect(renderContext.render).toBeDefined();
+		expect(renderContext.renderPartial).toBeDefined();
+		expect(renderContext.json).toBeDefined();
+		expect(renderContext.html).toBeDefined();
+	});
+
+	describe('render', () => {
+		it('should call renderer.renderToResponse with partial: false', async () => {
+			RenderToResponse.mockClear();
+			InitializeRenderer.mockClear();
+			ExplicitInitializeRenderer.mockClear();
+			const props = { foo: 'bar' };
+			const options = { status: 201, headers: { 'X-Custom': '1' } };
+
+			const response = await renderContext.render(ViewFn, props, options);
+
+			expect(InitializeRenderer).toHaveBeenCalled();
+			expect(RenderToResponse).toHaveBeenCalledWith(ViewFn, props, {
+				partial: false,
+				status: 201,
+				headers: { 'X-Custom': '1' },
+			});
+			expect(response instanceof Response).toBe(true);
+		});
+
+		it('should throw if view integration is unknown', async () => {
+			const badViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
+			badViewFn.config = { __eco: { id: 'test', file: '/bad-view.ts', integration: 'unknown' } };
+			await expect(renderContext.render(badViewFn, {})).rejects.toThrow('No integration found for: unknown');
+		});
+
+		it('should throw if view integration is missing', async () => {
+			const badViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
+			badViewFn.config = { __eco: undefined };
+			await expect(renderContext.render(badViewFn, {})).rejects.toThrow('Cannot determine integration for view');
+		});
+
+		it('should prefer explicit config.integration over injected metadata', async () => {
+			RenderToResponse.mockClear();
+			InitializeRenderer.mockClear();
+			ExplicitInitializeRenderer.mockClear();
+
+			const explicitViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
+			explicitViewFn.config = {
+				integration: 'explicit-renderer',
+				__eco: { id: 'test', file: '/some/file.tsx', integration: '-integration' },
+			};
+
+			await renderContext.render(explicitViewFn, {});
+
+			expect(ExplicitInitializeRenderer).toHaveBeenCalled();
+			expect(InitializeRenderer).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('renderPartial', () => {
+		it('should call renderer.renderToResponse with partial: true', async () => {
+			RenderToResponse.mockClear();
+			const props = { foo: 'bar' };
+			const options = { status: 200 };
+
+			await renderContext.renderPartial(ViewFn, props, options);
+
+			expect(InitializeRenderer).toHaveBeenCalled();
+			expect(RenderToResponse).toHaveBeenCalledWith(ViewFn, props, {
+				partial: true,
+				status: 200,
+				headers: undefined,
+			});
+		});
+	});
+
+	describe('json', () => {
+		it('should return a JSON response', async () => {
+			const data = { hello: 'world' };
+			const response = renderContext.json(data);
+			expect(response.headers.get('Content-Type')).toContain('application/json');
+			expect(await response.json()).toEqual(data);
+		});
+
+		it('should support custom status and headers', async () => {
+			const response = renderContext.json({}, { status: 201, headers: { 'X-Test': 'true' } });
+			expect(response.status).toBe(201);
+			expect(response.headers.get('X-Test')).toBe('true');
+		});
+	});
+
+	describe('html', () => {
+		it('should return an HTML response', async () => {
+			const html = '<div>hello</div>';
+			const response = renderContext.html(html);
+			expect(response.headers.get('Content-Type')).toContain('text/html');
+			expect(await response.text()).toBe(html);
+		});
+	});
+});

package/src/adapters/shared/render-context.ts

@@ -1,5 +1,8 @@
 import type { EcoComponent, RenderContext, RenderOptions, ResponseOptions } from '../../public-types.ts';
-import type { IntegrationRenderer, RenderToResponseContext } from '../../route-renderer/integration-renderer.ts';
+import type {
+	IntegrationRenderer,
+	RenderToResponseContext,
+} from '../../route-renderer/orchestration/integration-renderer.ts';
 import type { IntegrationPlugin } from '../../plugins/integration-plugin.ts';
 import { invariant } from '../../utils/invariant.ts';
 
@@ -51,10 +54,15 @@ export function createRenderContext(options: CreateRenderContextOptions): Render
 		return integration.initializeRenderer();
 	};
 
-	return {
-		async render<P>(view: EcoComponent<P>, props: P, renderOptions?: RenderOptions): Promise<Response> {
+	const renderContext: RenderContext = {
+		async render<P>(
+			this: { locals?: Record<string, unknown> } | undefined,
+			view: EcoComponent<P>,
+			props?: P,
+			renderOptions?: RenderOptions,
+		): Promise<Response> {
 			const locals = (this as { locals?: Record<string, unknown> } | undefined)?.locals;
-			const mergedProps = mergePropsWithLocals(props, locals);
+			const mergedProps = mergePropsWithLocals<P>(props ?? ({} as P), locals);
 
 			const renderer = getRendererForView(view);
 			const ctx: RenderToResponseContext = {
@@ -65,9 +73,14 @@ export function createRenderContext(options: CreateRenderContextOptions): Render
 			return renderer.renderToResponse(view, mergedProps, ctx);
 		},
 
-		async renderPartial<P>(view: EcoComponent<P>, props: P, renderOptions?: RenderOptions): Promise<Response> {
+		async renderPartial<P>(
+			this: { locals?: Record<string, unknown> } | undefined,
+			view: EcoComponent<P>,
+			props: P,
+			renderOptions?: RenderOptions,
+		): Promise<Response> {
 			const locals = (this as { locals?: Record<string, unknown> } | undefined)?.locals;
-			const mergedProps = mergePropsWithLocals(props, locals);
+			const mergedProps = mergePropsWithLocals<P>(props, locals);
 
 			const renderer = getRendererForView(view);
 			const ctx: RenderToResponseContext = {
@@ -102,4 +115,6 @@ export function createRenderContext(options: CreateRenderContextOptions): Render
 			});
 		},
 	};
+
+	return renderContext;
 }

package/src/adapters/shared/runtime-bootstrap.ts

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import { getAppBrowserBuildPlugins, setupAppRuntimePlugins, type BuildExecutor } from '../../build/build-adapter.ts';
+import type { EcoBuildPlugin } from '../../build/build-types.ts';
+import { installAppRuntimeBuildExecutor } from '../../build/runtime-build-executor.ts';
+import { RESOLVED_ASSETS_DIR } from '../../constants.ts';
+import type { EcoPagesAppConfig, IClientBridge, IHmrManager } from '../../internal-types.ts';
+import { ProjectWatcher } from '../../watchers/project-watcher.ts';
+
+/**
+ * Installs and returns the app-owned runtime build executor used by adapter
+ * startup and follow-up runtime work.
+ */
+export function installSharedRuntimeBuildExecutor(
+	appConfig: EcoPagesAppConfig,
+	options: { development: boolean },
+): BuildExecutor {
+	return installAppRuntimeBuildExecutor(appConfig, options);
+}
+
+/**
+ * Copies app public assets into dist and ensures the resolved assets directory
+ * exists before request handling begins.
+ */
+export function prepareSharedRuntimePublicDir(appConfig: EcoPagesAppConfig): void {
+	const srcPublicDir = path.join(appConfig.rootDir, appConfig.srcDir, appConfig.publicDir);
+
+	if (fileSystem.exists(srcPublicDir)) {
+		fileSystem.copyDir(srcPublicDir, path.join(appConfig.rootDir, appConfig.distDir));
+	}
+
+	fileSystem.ensureDir(path.join(appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR));
+}
+
+/**
+ * Runs runtime plugin setup against app-owned config/runtime state and optional
+ * host plugin registration hooks.
+ */
+export async function initializeSharedRuntimePlugins(options: {
+	appConfig: EcoPagesAppConfig;
+	runtimeOrigin: string;
+	hmrManager?: IHmrManager;
+	onRuntimePlugin?: (plugin: unknown) => void;
+}): Promise<void> {
+	await setupAppRuntimePlugins(options);
+}
+
+/**
+ * Starts shared project watching for runtime adapters.
+ */
+export async function startSharedProjectWatching(options: {
+	appConfig: EcoPagesAppConfig;
+	refreshRouterRoutesCallback: () => Promise<void>;
+	hmrManager: IHmrManager;
+	bridge: IClientBridge;
+}): Promise<void> {
+	const watcher = new ProjectWatcher({
+		config: options.appConfig,
+		refreshRouterRoutesCallback: options.refreshRouterRoutesCallback,
+		hmrManager: options.hmrManager,
+		bridge: options.bridge,
+	});
+
+	await watcher.createWatcherSubscription();
+}
+
+/**
+ * Binds a runtime HMR manager to app-owned plugin and integration state.
+ */
+export function bindSharedRuntimeHmrManager(appConfig: EcoPagesAppConfig, hmrManager: IHmrManager): EcoBuildPlugin[] {
+	const browserBuildPlugins = getAppBrowserBuildPlugins(appConfig);
+	hmrManager.setPlugins(browserBuildPlugins);
+
+	for (const integration of appConfig.integrations) {
+		integration.setHmrManager(hmrManager);
+	}
+
+	return browserBuildPlugins;
+}

package/src/adapters/shared/server-adapter.test.ts

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, test } from 'vitest';
+import { ConfigBuilder } from '../../config/config-builder.ts';
+import type { ServerAdapterResult } from '../abstract/server-adapter.ts';
+import { SharedServerAdapter } from './server-adapter.ts';
+
+const tempRoots: string[] = [];
+
+function createTempRoot(prefix: string): string {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
+	tempRoots.push(root);
+	return root;
+}
+
+afterEach(() => {
+	for (const root of tempRoots.splice(0)) {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});
+
+class TestSharedServerAdapter extends SharedServerAdapter<any, ServerAdapterResult> {
+	public async initialize(): Promise<void> {}
+	public getServerOptions(): Record<string, never> {
+		return {};
+	}
+	public async buildStatic(): Promise<void> {}
+	public async createAdapter(): Promise<ServerAdapterResult> {
+		return {
+			getServerOptions: () => ({}),
+			buildStatic: async () => {},
+		};
+	}
+	public async handleRequest(request: Request): Promise<Response> {
+		return await this.handleSharedRequest(request, {
+			apiHandlers: [],
+			hmrManager: {
+				getRuntimePath: () => '',
+				getDistDir: () => this.hmrDir,
+			},
+		});
+	}
+
+	constructor(
+		private readonly hmrDir: string,
+		rootDir: string,
+	) {
+		super({
+			appConfig: { rootDir } as any,
+			runtimeOrigin: 'http://localhost:3000',
+			serveOptions: {},
+			options: {},
+		});
+	}
+}
+
+test('SharedServerAdapter serves /assets/_hmr files from the HMR manager directory', async () => {
+	const rootDir = createTempRoot('ecopages-shared-server-hmr-assets');
+	const config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const hmrDir = path.join(config.absolutePaths.workDir, 'assets', '_hmr');
+	const assetPath = path.join(hmrDir, 'pages', 'react-content.js');
+	fs.mkdirSync(path.dirname(assetPath), { recursive: true });
+	fs.writeFileSync(assetPath, 'export default 1;', 'utf8');
+
+	const adapter = new TestSharedServerAdapter(hmrDir, rootDir);
+	const response = await adapter.handleRequest(new Request('http://localhost/assets/_hmr/pages/react-content.js'));
+
+	assert.equal(response.status, 200);
+	assert.equal(response.headers.get('Content-Type'), 'application/javascript');
+	assert.equal(await response.text(), 'export default 1;');
+	assert.equal(
+		fs.existsSync(path.join(config.absolutePaths.distDir, 'assets', '_hmr', 'pages', 'react-content.js')),
+		false,
+	);
+});

package/src/adapters/shared/server-adapter.ts

@@ -2,11 +2,11 @@ import path from 'node:path';
 import { AbstractServerAdapter } from '../abstract/server-adapter.ts';
 import type { ServerAdapterOptions, ServerAdapterResult } from '../abstract/server-adapter.ts';
 import { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
-import { FSRouter } from '../../router/fs-router.ts';
-import { FSRouterScanner } from '../../router/fs-router-scanner.ts';
+import { FSRouter } from '../../router/server/fs-router.ts';
+import { FSRouterScanner } from '../../router/server/fs-router-scanner.ts';
 import { MemoryCacheStore } from '../../services/cache/memory-cache-store.ts';
 import { PageCacheService } from '../../services/cache/page-cache-service.ts';
-import { SchemaValidationService } from '../../services/schema-validation-service.ts';
+import { SchemaValidationService } from '../../services/validation/schema-validation-service.ts';
 import { StaticSiteGenerator } from '../../static-site-generator/static-site-generator.ts';
 import { ServerStaticBuilder } from './server-static-builder.ts';
 import { ExplicitStaticRouteMatcher } from './explicit-static-route-matcher.ts';
@@ -18,6 +18,7 @@ import { createRequire } from '../../utils/locals-utils.ts';
 import { HttpError } from '../../errors/http-error.ts';
 import { ApiResponseBuilder } from './api-response.ts';
 import { appLogger } from '../../global/app-logger.ts';
+import { fileSystem } from '@ecopages/file-system';
 import type {
 	ApiHandler,
 	ApiHandlerContext,
@@ -39,6 +40,41 @@ export abstract class SharedServerAdapter<
 	protected staticBuilder!: ServerStaticBuilder;
 	protected readonly schemaValidator = new SchemaValidationService();
 
+	protected async initializeSharedRouteHandling(options: {
+		staticRoutes: StaticRoute[];
+		hmrManager?: any;
+	}): Promise<void> {
+		await this.initSharedRouter();
+		this.configureSharedResponseHandlers(options.staticRoutes, options.hmrManager);
+	}
+
+	protected createSharedWatchRefreshCallback(options: {
+		staticRoutes: StaticRoute[];
+		hmrManager?: any;
+		onRoutesReady?: () => Promise<void> | void;
+		onError?: (error: Error) => Promise<void> | void;
+	}): () => Promise<void> {
+		return async () => {
+			try {
+				await this.initializeSharedRouteHandling({
+					staticRoutes: options.staticRoutes,
+					hmrManager: options.hmrManager,
+				});
+
+				if (options.onRoutesReady) {
+					await options.onRoutesReady();
+				}
+			} catch (error) {
+				if (options.onError) {
+					await options.onError(error instanceof Error ? error : new Error(String(error)));
+					return;
+				}
+
+				throw error;
+			}
+		};
+	}
+
 	/**
 	 * Scans the filesystem and dynamically constructs the universal router map.
 	 *
@@ -108,6 +144,7 @@ export abstract class SharedServerAdapter<
 		}
 
 		this.fileSystemResponseMatcher = new FileSystemResponseMatcher({
+			appConfig: this.appConfig,
 			router: this.router,
 			routeRendererFactory: this.routeRendererFactory,
 			fileSystemResponseFactory,
@@ -418,7 +455,6 @@ export abstract class SharedServerAdapter<
 
 		if (url.pathname === '/_hmr_runtime.js' && context.hmrManager) {
 			const runtimePath = context.hmrManager.getRuntimePath();
-			const fileSystem = (await import('@ecopages/file-system')).fileSystem;
 			if (fileSystem.exists(runtimePath)) {
 				return new Response(fileSystem.readFileAsBuffer(runtimePath) as BodyInit, {
 					headers: { 'Content-Type': 'application/javascript' },
@@ -426,6 +462,17 @@ export abstract class SharedServerAdapter<
 			}
 		}
 
+		if (url.pathname.startsWith('/assets/_hmr/') && context.hmrManager) {
+			const relativePath = url.pathname.slice('/assets/_hmr/'.length);
+			const assetPath = path.join(context.hmrManager.getDistDir(), relativePath);
+
+			if (fileSystem.exists(assetPath)) {
+				return new Response(fileSystem.readFileAsBuffer(assetPath) as BodyInit, {
+					headers: { 'Content-Type': 'application/javascript' },
+				});
+			}
+		}
+
 		const apiMatch = this.matchApiHandler(request, context.apiHandlers);
 		if (apiMatch) {
 			return this.executeApiHandler(

package/src/adapters/shared/server-route-handler.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ServerRouteHandler } from './server-route-handler';
+import type { FSRouter } from '../../router/server/fs-router';
+import type { FileSystemResponseMatcher } from './fs-server-response-matcher';
+import type { IHmrManager } from '../../public-types';
+
+function createMockDependencies() {
+	const Router = {
+		match: vi.fn(() => null),
+	} as unknown as FSRouter;
+
+	const FileSystemResponseMatcher = {
+		handleMatch: vi.fn(() => Promise.resolve(new Response('Matched Content'))),
+		handleNoMatch: vi.fn(() => Promise.resolve(new Response('Not Found', { status: 404 }))),
+	} as unknown as FileSystemResponseMatcher;
+
+	const HmrManager = {
+		isEnabled: vi.fn(() => true),
+		broadcast: vi.fn(),
+	} as unknown as IHmrManager;
+
+	return {
+		Router,
+		FileSystemResponseMatcher,
+		HmrManager,
+	};
+}
+
+describe('ServerRouteHandler', () => {
+	describe('handleResponse', () => {
+		it('should delegate to fileSystemResponseMatcher when route matches', async () => {
+			const { Router, FileSystemResponseMatcher } = createMockDependencies();
+			const handler = new ServerRouteHandler({
+				router: Router,
+				fileSystemResponseMatcher: FileSystemResponseMatcher,
+			});
+
+			Router.match = vi.fn(
+				() =>
+					({
+						/* match */
+					}) as any,
+			);
+			const request = new Request('http://localhost/test');
+			const response = await handler.handleResponse(request);
+
+			expect(FileSystemResponseMatcher.handleMatch).toHaveBeenCalled();
+			expect(response.status).toBe(200);
+		});
+
+		it('should delegate to handleNoMatch when route does not match', async () => {
+			const { Router, FileSystemResponseMatcher } = createMockDependencies();
+			const handler = new ServerRouteHandler({
+				router: Router,
+				fileSystemResponseMatcher: FileSystemResponseMatcher,
+			});
+
+			const request = new Request('http://localhost/unknown');
+			const response = await handler.handleResponse(request);
+
+			expect(FileSystemResponseMatcher.handleNoMatch).toHaveBeenCalled();
+			expect(response.status).toBe(404);
+		});
+
+		it('should inject HMR script in watch mode for HTML responses', async () => {
+			const { Router, FileSystemResponseMatcher, HmrManager } = createMockDependencies();
+			const handler = new ServerRouteHandler({
+				router: Router,
+				fileSystemResponseMatcher: FileSystemResponseMatcher,
+				watch: true,
+				hmrManager: HmrManager,
+			});
+
+			Router.match = vi.fn(() => ({}) as any);
+			FileSystemResponseMatcher.handleMatch = vi.fn(() =>
+				Promise.resolve(
+					new Response('<html><body></body></html>', { headers: { 'Content-Type': 'text/html' } }),
+				),
+			);
+
+			const request = new Request('http://localhost/test');
+			const response = await handler.handleResponse(request);
+			const text = await response.text();
+
+			expect(text).toContain("import '/_hmr_runtime.js'");
+		});
+	});
+
+	describe('handleNoMatch', () => {
+		it('should broadcast error if handleNoMatch throws', async () => {
+			const { Router, FileSystemResponseMatcher, HmrManager } = createMockDependencies();
+			const handler = new ServerRouteHandler({
+				router: Router,
+				fileSystemResponseMatcher: FileSystemResponseMatcher,
+				watch: true,
+				hmrManager: HmrManager,
+			});
+
+			FileSystemResponseMatcher.handleNoMatch = vi.fn(() => {
+				throw new Error('Test Error');
+			});
+
+			const request = new Request('http://localhost/unknown');
+			const response = await handler.handleNoMatch(request);
+
+			expect(response.status).toBe(500);
+			expect(HmrManager.broadcast).toHaveBeenCalledWith({ type: 'error', message: 'Test Error' });
+		});
+	});
+});

package/src/adapters/shared/server-route-handler.ts

@@ -1,9 +1,10 @@
 import type { IHmrManager } from '../../public-types';
-import type { FSRouter } from '../../router/fs-router';
+import type { FSRouter } from '../../router/server/fs-router';
 import type { ExplicitStaticRouteMatcher } from './explicit-static-route-matcher';
 import type { FileSystemResponseMatcher } from './fs-server-response-matcher';
 import { appLogger } from '../../global/app-logger';
 import { HttpError } from '../../errors/http-error';
+import { injectHmrRuntimeIntoHtmlResponse, isHtmlResponse, shouldInjectHmrHtmlResponse } from './hmr-html-response';
 
 /**
  * Configuration parameters for ServerRouteHandler.
@@ -63,7 +64,7 @@ export class ServerRouteHandler {
 	 * @returns true if in watch mode and HMR manager is enabled
 	 */
 	shouldInjectHmrScript(): boolean {
-		return this.watch && this.hmrManager?.isEnabled() === true;
+		return shouldInjectHmrHtmlResponse(this.watch, this.hmrManager);
 	}
 
 	/**
@@ -73,8 +74,7 @@ export class ServerRouteHandler {
 	 * @returns true if Content-Type header starts with 'text/html'
 	 */
 	isHtmlResponse(response: Response): boolean {
-		const contentType = response.headers.get('Content-Type');
-		return contentType !== null && contentType.startsWith('text/html');
+		return isHtmlResponse(response);
 	}
 
 	/**
@@ -118,20 +118,7 @@ export class ServerRouteHandler {
 	 */
 	private async maybeInjectHmrScript(response: Response): Promise<Response> {
 		if (this.shouldInjectHmrScript() && this.isHtmlResponse(response)) {
-			const html = await response.text();
-
-			const hmrScript = `<script type="module">import '/_hmr_runtime.js';</script>`;
-
-			const updatedHtml = html.replace(/<\/html>/i, `${hmrScript}</html>`);
-
-			const headers = new Headers(response.headers);
-			headers.delete('Content-Length');
-
-			return new Response(updatedHtml, {
-				status: response.status,
-				statusText: response.statusText,
-				headers,
-			});
+			return injectHmrRuntimeIntoHtmlResponse(response);
 		}
 
 		return response;