@ecopages/core 0.2.0-alpha.53 → 0.2.0-alpha.54

package/src/adapters/shared/fs-server-response-matcher.test.ts

@@ -0,0 +1,311 @@
+import { describe, expect, it, vi } from 'vitest';
+import { fileSystem } from '@ecopages/file-system';
+import path from 'node:path';
+import { APP_TEST_ROUTES, FIXTURE_APP_PROJECT_DIR, INDEX_TEMPLATE_FILE } from '../../../__fixtures__/constants.ts';
+import { ConfigBuilder } from '../../config/config-builder.ts';
+import type { MatchResult } from '../../types/internal-types.ts';
+import { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
+import { RouteRegistry } from '../../router/server/route-registry.ts';
+import { MemoryCacheStore } from '../../services/cache/memory-cache-store.ts';
+import { PageCacheService } from '../../services/cache/page-cache-service.ts';
+import { FileSystemServerResponseFactory } from './fs-server-response-factory.ts';
+import { FileSystemResponseMatcher } from './fs-server-response-matcher.ts';
+
+const appConfig = await new ConfigBuilder().setRootDir(FIXTURE_APP_PROJECT_DIR).build();
+
+for (const integration of appConfig.integrations) {
+	integration.setConfig(appConfig);
+	integration.setRuntimeOrigin(appConfig.baseUrl);
+}
+
+const router = new RouteRegistry({
+	pagesDir: path.join(appConfig.rootDir, appConfig.srcDir, appConfig.pagesDir),
+	appConfig,
+	origin: appConfig.baseUrl,
+	templatesExt: appConfig.templatesExt,
+	buildMode: false,
+	pageModuleAdapter: {
+		loadPageModule: vi.fn(async () => ({})),
+	},
+});
+
+await router.init();
+
+const routeRendererFactory = new RouteRendererFactory({
+	appConfig,
+	runtimeOrigin: appConfig.baseUrl,
+});
+
+const fileSystemResponseFactory = new FileSystemServerResponseFactory({
+	options: {
+		watchMode: false,
+	},
+});
+
+describe('FileSystemResponseMatcher', () => {
+	describe('without cache service', () => {
+		const matcherWithoutCache = new FileSystemResponseMatcher({
+			appConfig,
+			assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
+			router,
+			routeRendererFactory,
+			fileSystemResponseFactory,
+		});
+
+		it('should return custom 404 page for unmatched request URL', async () => {
+			const requestUrl = APP_TEST_ROUTES.nonExistentFile;
+			const response = await matcherWithoutCache.handleNoMatch(requestUrl);
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should handle match with disabled cache headers', async () => {
+			const match: MatchResult = {
+				requestedPathname: APP_TEST_ROUTES.index,
+				templateRoute: {
+					kind: 'exact',
+					pathname: APP_TEST_ROUTES.index,
+					filePath: INDEX_TEMPLATE_FILE,
+				},
+				params: {},
+				query: {},
+			};
+			const response = await matcherWithoutCache.handleMatch(match);
+			expect(response.headers.get('Content-Type')).toBe('text/html');
+			expect(response.headers.get('X-Cache')).toBe('DISABLED');
+			expect(response.headers.get('Cache-Control')).toBe('no-store, must-revalidate');
+		});
+
+		it('should return null for getCacheService when not configured', () => {
+			expect(matcherWithoutCache.getCacheService()).toBeNull();
+		});
+	});
+
+	describe('with cache service', () => {
+		const cacheService = new PageCacheService({
+			store: new MemoryCacheStore(),
+			enabled: true,
+		});
+
+		const matcherWithCache = new FileSystemResponseMatcher({
+			appConfig,
+			assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
+			router,
+			routeRendererFactory,
+			fileSystemResponseFactory,
+			cacheService,
+			defaultCacheStrategy: 'static',
+		});
+
+		it('should return cache service via getCacheService', () => {
+			expect(matcherWithCache.getCacheService()).toBe(cacheService);
+		});
+
+		it('should return X-Cache header on first request (MISS)', async () => {
+			const match: MatchResult = {
+				requestedPathname: '/cache-test-miss',
+				templateRoute: {
+					kind: 'exact',
+					pathname: '/cache-test-miss',
+					filePath: INDEX_TEMPLATE_FILE,
+				},
+				params: {},
+				query: {},
+			};
+			const response = await matcherWithCache.handleMatch(match);
+			expect(response.headers.get('X-Cache')).toBe('MISS');
+			expect(response.headers.get('Cache-Control')).toBe('public, max-age=31536000, immutable');
+		});
+
+		it('should return X-Cache HIT on second request to same path', async () => {
+			const uniquePath = `/cache-test-hit-${Date.now()}`;
+			const match: MatchResult = {
+				requestedPathname: uniquePath,
+				templateRoute: {
+					kind: 'exact',
+					pathname: uniquePath,
+					filePath: INDEX_TEMPLATE_FILE,
+				},
+				params: {},
+				query: {},
+			};
+
+			const response1 = await matcherWithCache.handleMatch(match);
+			const response2 = await matcherWithCache.handleMatch(match);
+
+			expect(response1.headers.get('X-Cache')).toBe('MISS');
+			expect(response2.headers.get('X-Cache')).toBe('HIT');
+		});
+
+		it('should cache different paths separately', async () => {
+			const match1: MatchResult = {
+				requestedPathname: '/path-a',
+				templateRoute: {
+					kind: 'exact',
+					pathname: '/path-a',
+					filePath: INDEX_TEMPLATE_FILE,
+				},
+				params: {},
+				query: {},
+			};
+			const match2: MatchResult = {
+				requestedPathname: '/path-b',
+				templateRoute: {
+					kind: 'exact',
+					pathname: '/path-b',
+					filePath: INDEX_TEMPLATE_FILE,
+				},
+				params: {},
+				query: {},
+			};
+
+			const response1 = await matcherWithCache.handleMatch(match1);
+			const response2 = await matcherWithCache.handleMatch(match2);
+
+			expect(response1.headers.get('X-Cache')).toBe('MISS');
+			expect(response2.headers.get('X-Cache')).toBe('MISS');
+		});
+
+		it('should include query params in cache key', async () => {
+			const basePath = `/search-${Date.now()}`;
+			const matchWithQuery: MatchResult = {
+				requestedPathname: basePath,
+				templateRoute: {
+					kind: 'exact',
+					pathname: basePath,
+					filePath: INDEX_TEMPLATE_FILE,
+				},
+				params: {},
+				query: { q: 'test' },
+			};
+			const matchWithDifferentQuery: MatchResult = {
+				requestedPathname: basePath,
+				templateRoute: {
+					kind: 'exact',
+					pathname: basePath,
+					filePath: INDEX_TEMPLATE_FILE,
+				},
+				params: {},
+				query: { q: 'other' },
+			};
+
+			const firstCall = await matcherWithCache.handleMatch(matchWithQuery);
+			const response1 = await matcherWithCache.handleMatch(matchWithQuery);
+			const response2 = await matcherWithCache.handleMatch(matchWithDifferentQuery);
+
+			expect(firstCall.headers.get('X-Cache')).toBe('MISS');
+			expect(response1.headers.get('X-Cache')).toBe('HIT');
+			expect(response2.headers.get('X-Cache')).toBe('MISS');
+		});
+	});
+
+	describe('with dynamic cache strategy', () => {
+		const cacheService = new PageCacheService({
+			store: new MemoryCacheStore(),
+			enabled: true,
+		});
+
+		const dynamicMatcher = new FileSystemResponseMatcher({
+			appConfig,
+			assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
+			router,
+			routeRendererFactory,
+			fileSystemResponseFactory,
+			cacheService,
+			defaultCacheStrategy: 'dynamic',
+		});
+
+		it('should bypass cache entirely for dynamic strategy', async () => {
+			const match: MatchResult = {
+				requestedPathname: '/dynamic-page',
+				templateRoute: {
+					kind: 'exact',
+					pathname: '/dynamic-page',
+					filePath: INDEX_TEMPLATE_FILE,
+				},
+				params: {},
+				query: {},
+			};
+
+			const response1 = await dynamicMatcher.handleMatch(match);
+			const response2 = await dynamicMatcher.handleMatch(match);
+
+			expect(response1.headers.get('X-Cache')).toBe('DISABLED');
+			expect(response2.headers.get('X-Cache')).toBe('DISABLED');
+			expect(response1.headers.get('Cache-Control')).toBe('no-store, must-revalidate');
+		});
+	});
+
+	describe('handleNoMatch content type behavior', () => {
+		const matcher = new FileSystemResponseMatcher({
+			appConfig,
+			assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
+			router,
+			routeRendererFactory,
+			fileSystemResponseFactory,
+		});
+
+		it('should return custom 404 page for known extension like .html', async () => {
+			const response = await matcher.handleNoMatch('/non-existent-page.html');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should return custom 404 page for page requests without extension', async () => {
+			const response = await matcher.handleNoMatch('/non-existent-page');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should return custom 404 page for unknown extensions', async () => {
+			const response = await matcher.handleNoMatch('/page.xyz');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should return custom 404 page for trailing dot', async () => {
+			const response = await matcher.handleNoMatch('/page.');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should serve text/plain files from disk', async () => {
+			const readFileAsBuffer = vi.spyOn(fileSystem, 'readFileAsBuffer').mockReturnValue(Buffer.from('robots'));
+			const response = await matcher.handleNoMatch('/robots.txt');
+			readFileAsBuffer.mockRestore();
+			expect(response.headers.get('Content-Type')).toBe('text/plain');
+		});
+
+		it('should return custom 404 page for non-existent static files', async () => {
+			const response = await matcher.handleNoMatch('/non-existent.txt');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+	});
+
+	describe('internal transpile output', () => {
+		it('should inspect page modules through the owning route renderer', async () => {
+			const matcher = new FileSystemResponseMatcher({
+				appConfig,
+				assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
+				router,
+				routeRendererFactory,
+				fileSystemResponseFactory,
+			});
+
+			const loadPageModule = vi.fn(async () => ({}));
+			(matcher as any).routeRendererFactory = {
+				getPageRenderer: vi.fn(() => ({
+					loadPageModule,
+				})),
+			};
+
+			await (matcher as any).importPageModule(INDEX_TEMPLATE_FILE);
+
+			expect((matcher as any).routeRendererFactory.getPageRenderer).toHaveBeenCalledWith(INDEX_TEMPLATE_FILE);
+			expect(loadPageModule).toHaveBeenCalledWith(INDEX_TEMPLATE_FILE, {
+				cacheScope: 'request-metadata',
+			});
+		});
+	});
+});

package/src/adapters/shared/fs-server-response-matcher.ts

@@ -0,0 +1,240 @@
+import path from 'node:path';
+import { appLogger } from '../../global/app-logger.ts';
+import type { EcoPagesAppConfig, MatchResult } from '../../types/internal-types.ts';
+import type { PageRendererResolver } from '../../route-renderer/route-renderer.ts';
+import type { RouteRegistry } from '../../router/server/route-registry.ts';
+import type { PageCacheService } from '../../services/cache/page-cache-service.ts';
+import type { CacheStrategy, RenderResult } from '../../services/cache/cache.types.ts';
+import { PageRequestCacheCoordinator } from '../../services/cache/page-request-cache-coordinator.service.ts';
+import { ServerUtils } from '../../utils/server-utils.module.ts';
+import type { FileRouteMiddleware, RequestLocals } from '../../types/public-types.ts';
+import { FileRouteMiddlewarePipeline } from './file-route-middleware-pipeline.ts';
+import { LocalsAccessError } from '../../errors/locals-access-error.ts';
+import { isDevelopmentRuntime } from '../../utils/runtime.ts';
+import type { FileSystemServerResponseFactory } from './fs-server-response-factory.ts';
+
+type FileRouteExecutionPlan = {
+	cacheKey: string;
+	request: Request;
+	pageFilePath: string;
+	pageMiddleware: FileRouteMiddleware[];
+	pageCacheStrategy: CacheStrategy;
+	localsStore: RequestLocals;
+	localsForRender: RequestLocals | undefined;
+};
+
+export interface FileSystemResponseMatcherOptions {
+	appConfig: EcoPagesAppConfig;
+	assetPrefix: string;
+	router: RouteRegistry;
+	routeRendererFactory: PageRendererResolver;
+	fileSystemResponseFactory: FileSystemServerResponseFactory;
+	/** Optional cache service. When null, caching is disabled. */
+	cacheService?: PageCacheService | null;
+	/** Default cache strategy when caching is enabled. @default 'static' */
+	defaultCacheStrategy?: CacheStrategy;
+}
+
+/**
+ * Matches file-system routes to rendered HTML responses.
+ *
+ * This render pipeline coordinates page module inspection, request-local policy,
+ * renderer invocation, middleware execution, cache integration, and fallback
+ * error translation.
+ */
+export class FileSystemResponseMatcher {
+	private appConfig: EcoPagesAppConfig;
+	private assetPrefix: string;
+	private router: RouteRegistry;
+	private routeRendererFactory: PageRendererResolver;
+	private fileSystemResponseFactory: FileSystemServerResponseFactory;
+	private pageRequestCacheCoordinator: PageRequestCacheCoordinator;
+	private fileRouteMiddlewarePipeline: FileRouteMiddlewarePipeline;
+
+	constructor({
+		appConfig,
+		assetPrefix,
+		router,
+		routeRendererFactory,
+		fileSystemResponseFactory,
+		cacheService = null,
+		defaultCacheStrategy = 'static',
+	}: FileSystemResponseMatcherOptions) {
+		this.appConfig = appConfig;
+		this.assetPrefix = assetPrefix;
+		this.router = router;
+		this.routeRendererFactory = routeRendererFactory;
+		this.fileSystemResponseFactory = fileSystemResponseFactory;
+		this.pageRequestCacheCoordinator = new PageRequestCacheCoordinator(cacheService, defaultCacheStrategy);
+		this.fileRouteMiddlewarePipeline = new FileRouteMiddlewarePipeline(cacheService);
+	}
+
+	/**
+	 * Resolves unmatched paths either as static asset requests or as the custom
+	 * not-found page.
+	 * @param requestUrl Incoming pathname.
+	 * @returns Static file response or rendered 404 response.
+	 */
+	async handleNoMatch(requestUrl: string): Promise<Response> {
+		const isStaticFileRequest = ServerUtils.hasKnownExtension(requestUrl);
+
+		if (!isStaticFileRequest) {
+			return this.renderCustomNotFoundResponse();
+		}
+
+		const relativeUrl = requestUrl.startsWith('/') ? requestUrl.slice(1) : requestUrl;
+		const filePath = path.join(this.assetPrefix, relativeUrl);
+		const contentType = ServerUtils.getContentType(filePath);
+
+		const response = await this.fileSystemResponseFactory.createFileResponse(filePath, contentType);
+		return response ?? this.renderCustomNotFoundResponse();
+	}
+
+	/**
+	 * Handles a matched file-system page route.
+	 *
+	 * The method inspects page metadata needed for request-time execution,
+	 * prepares the renderer invocation, validates middleware/cache constraints,
+	 * and delegates caching plus middleware execution to dedicated collaborators.
+	 *
+	 * @param match Router match result.
+	 * @param request Optional incoming request. A synthetic GET request is created when omitted.
+	 * @returns Final response for the matched route.
+	 */
+	async handleMatch(match: MatchResult, request?: Request): Promise<Response> {
+		try {
+			const executionPlan = await this.createExecutionPlan(match, request);
+
+			this.fileRouteMiddlewarePipeline.assertValidConfiguration({
+				middleware: executionPlan.pageMiddleware,
+				pageCacheStrategy: executionPlan.pageCacheStrategy,
+				filePath: executionPlan.pageFilePath,
+			});
+
+			const routeRenderer = this.routeRendererFactory.getPageRenderer(executionPlan.pageFilePath);
+			const middlewareContext = this.fileRouteMiddlewarePipeline.createContext({
+				request: executionPlan.request,
+				params: match.params as Record<string, string>,
+				locals: executionPlan.localsStore,
+			});
+
+			const renderFn = async (): Promise<RenderResult> => {
+				const result = await routeRenderer.execute({
+					file: executionPlan.pageFilePath,
+					params: match.params,
+					query: match.query,
+					locals: executionPlan.localsForRender,
+				});
+				const html = await this.pageRequestCacheCoordinator.bodyToString(result.body);
+				const strategy = result.cacheStrategy ?? this.pageRequestCacheCoordinator.getDefaultCacheStrategy();
+				return { html, strategy };
+			};
+			const renderResponse = async (): Promise<Response> => {
+				return this.pageRequestCacheCoordinator.render({
+					cacheKey: executionPlan.cacheKey,
+					pageCacheStrategy: executionPlan.pageCacheStrategy,
+					renderFn,
+				});
+			};
+
+			return await this.fileRouteMiddlewarePipeline.run({
+				middleware: executionPlan.pageMiddleware,
+				context: middlewareContext,
+				renderResponse,
+			});
+		} catch (error) {
+			if (error instanceof Response) {
+				return error;
+			}
+			if (error instanceof LocalsAccessError) {
+				return new Response(error.message, {
+					status: 500,
+					headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+				});
+			}
+			if (error instanceof Error) {
+				if (isDevelopmentRuntime() || appLogger.isDebugEnabled()) {
+					appLogger.error(`[FileSystemResponseMatcher] ${error.message} at ${match.requestedPathname}`);
+				}
+			}
+			return this.renderCustomNotFoundResponse();
+		}
+	}
+
+	/**
+	 * Renders the app-owned custom 404 page, falling back to the default text 404
+	 * when the page template cannot be resolved.
+	 */
+	private async renderCustomNotFoundResponse(): Promise<Response> {
+		const error404TemplatePath = this.appConfig.absolutePaths.error404TemplatePath;
+
+		try {
+			const routeRenderer = this.routeRendererFactory.getPageRenderer(error404TemplatePath);
+			const result = await routeRenderer.execute({
+				file: error404TemplatePath,
+			});
+
+			return this.fileSystemResponseFactory.createHtmlNotFoundResponse(result.body);
+		} catch {
+			appLogger.debug(
+				'Custom 404 template not found, falling back to default 404 response',
+				error404TemplatePath,
+			);
+			return this.fileSystemResponseFactory.createDefaultNotFoundResponse();
+		}
+	}
+
+	private async createExecutionPlan(match: MatchResult, request?: Request): Promise<FileRouteExecutionPlan> {
+		const cacheKey = this.pageRequestCacheCoordinator.buildCacheKey({
+			pathname: match.requestedPathname,
+			query: match.query,
+		});
+		const resolvedRequest =
+			request ??
+			new Request(new URL(cacheKey, this.router.origin).toString(), {
+				method: 'GET',
+			});
+		const localsStore: RequestLocals = {};
+		const pageFilePath = match.templateRoute.filePath;
+		const pageModule = await this.importPageModule(pageFilePath);
+		const Page = (pageModule as any)?.default;
+		const pageMiddleware = (Page?.middleware ?? []) as FileRouteMiddleware[];
+		const pageCacheStrategy =
+			(Page?.cache as CacheStrategy | undefined) ?? this.pageRequestCacheCoordinator.getDefaultCacheStrategy();
+
+		return {
+			cacheKey,
+			request: resolvedRequest,
+			pageFilePath,
+			pageMiddleware,
+			pageCacheStrategy,
+			localsStore,
+			localsForRender: pageCacheStrategy === 'dynamic' ? localsStore : undefined,
+		};
+	}
+
+	/**
+	 * Loads the matched page module for request-time inspection.
+	 *
+	 * The matcher needs access to page-level metadata such as `cache` and
+	 * `middleware` before full rendering starts, so it asks the owning route
+	 * renderer to load the page module. That preserves integration-specific page
+	 * import setup for request-time inspection as well as for full rendering.
+	 *
+	 * @param filePath Absolute page module path.
+	 * @returns Imported page module.
+	 */
+	private async importPageModule(filePath: string): Promise<unknown> {
+		const routeRenderer = this.routeRendererFactory.getPageRenderer(filePath);
+		return routeRenderer.loadPageModule(filePath, {
+			cacheScope: 'request-metadata',
+		});
+	}
+
+	/**
+	 * Get the underlying cache service for external invalidation.
+	 */
+	getCacheService(): PageCacheService | null {
+		return this.pageRequestCacheCoordinator.getCacheService();
+	}
+}

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

@@ -0,0 +1,149 @@
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import { appLogger } from '../../global/app-logger.ts';
+import { RESOLVED_ASSETS_DIR } from '../../config/constants.ts';
+
+/**
+ * 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;
+}
+
+/**
+ * Runtime-specific hooks required to materialize a single HMR entrypoint.
+ */
+export interface HmrEntrypointRegistrationOptions {
+	/**
+	 * Emits the browser-consumable HMR artifact for an entrypoint.
+	 */
+	emit(entrypointPath: string, outputPath: string): Promise<void>;
+	/**
+	 * Creates the runtime-specific error raised when the emit hook completes without producing output.
+	 */
+	getMissingOutputError(entrypointPath: string, outputPath: string): Error;
+}
+
+/**
+ * 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.
+ */
+export class HmrEntrypointRegistrar {
+	private readonly options: HmrEntrypointRegistrarOptions;
+
+	constructor(options: HmrEntrypointRegistrarOptions) {
+		this.options = options;
+	}
+
+	/**
+	 * Registers a single source entrypoint and returns the browser URL for its emitted HMR module.
+	 *
+	 * Concurrent requests for the same normalized entrypoint share the same in-flight promise so the
+	 * integration only builds once per registration cycle.
+	 */
+	async registerEntrypoint(
+		entrypointPath: string,
+		registrationOptions: HmrEntrypointRegistrationOptions,
+	): Promise<string> {
+		const normalizedEntrypoint = path.resolve(entrypointPath);
+		const existingRegistration = this.options.entrypointRegistrations.get(normalizedEntrypoint);
+		if (existingRegistration) {
+			return await this.awaitEntrypointRegistration(existingRegistration, normalizedEntrypoint);
+		}
+
+		const registration = this.registerEntrypointInternal(normalizedEntrypoint, registrationOptions);
+		this.options.entrypointRegistrations.set(normalizedEntrypoint, registration);
+
+		try {
+			return await this.awaitEntrypointRegistration(registration, normalizedEntrypoint);
+		} catch (error) {
+			this.options.clearFailedRegistration?.(normalizedEntrypoint);
+			throw error;
+		} finally {
+			this.options.entrypointRegistrations.delete(normalizedEntrypoint);
+		}
+	}
+
+	private async registerEntrypointInternal(
+		entrypointPath: string,
+		registrationOptions: HmrEntrypointRegistrationOptions,
+	): Promise<string> {
+		if (this.options.watchedFiles.has(entrypointPath)) {
+			return this.options.watchedFiles.get(entrypointPath)!;
+		}
+
+		const { outputPath, outputUrl } = this.getEntrypointOutput(entrypointPath);
+
+		this.options.watchedFiles.set(entrypointPath, outputUrl);
+		this.removeStaleEntrypointOutput(outputPath);
+
+		await registrationOptions.emit(entrypointPath, outputPath);
+
+		if (!fileSystem.exists(outputPath)) {
+			throw registrationOptions.getMissingOutputError(entrypointPath, outputPath);
+		}
+
+		return outputUrl;
+	}
+
+	private async awaitEntrypointRegistration(registration: Promise<string>, entrypointPath: string): Promise<string> {
+		if (process.env.NODE_ENV !== 'development') {
+			return await registration;
+		}
+
+		return await Promise.race([
+			registration,
+			new Promise<string>((_, reject) => {
+				setTimeout(() => {
+					reject(new Error(`[HMR] Timed out registering entrypoint: ${entrypointPath}`));
+				}, this.options.registrationTimeoutMs);
+			}),
+		]);
+	}
+
+	private getEntrypointOutput(entrypointPath: string): { outputPath: string; outputUrl: string } {
+		const relativePath = path.relative(this.options.srcDir, entrypointPath);
+		const relativePathJs = relativePath.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
+		const encodedPathJs = this.encodeDynamicSegments(relativePathJs);
+		const urlPath = encodedPathJs.split(path.sep).join('/');
+
+		return {
+			outputUrl: `/${path.join(RESOLVED_ASSETS_DIR, '_hmr', urlPath)}`,
+			outputPath: path.join(this.options.distDir, urlPath),
+		};
+	}
+
+	private removeStaleEntrypointOutput(outputPath: string): void {
+		if (!fileSystem.exists(outputPath)) {
+			return;
+		}
+
+		try {
+			fileSystem.remove(outputPath);
+		} catch (error) {
+			appLogger.warn(
+				`[HMR] Failed to remove stale entrypoint output ${outputPath}: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
+	private encodeDynamicSegments(filepath: string): string {
+		return filepath.replace(/\[([^\]]+)\]/g, '_$1_');
+	}
+}