@ecopages/core 0.2.0-alpha.27 → 0.2.0-alpha.28

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

@@ -1,240 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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_');
-	}
-}

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

@@ -1,52 +0,0 @@
-import type { IHmrManager } from '../../types/public-types.ts';
-
-const HMR_RUNTIME_IMPORT = "import '/_hmr_runtime.js'";
-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: Response): boolean {
-	const contentType = response.headers.get('Content-Type');
-	return contentType !== null && contentType.startsWith('text/html');
-}
-
-/**
- * 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: boolean, hmrManager?: Pick<IHmrManager, 'isEnabled'>): boolean {
-	return watch && hmrManager?.isEnabled() === true;
-}
-
-/**
- * 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: Response): Promise<Response> {
-	const html = await response.text();
-	if (html.includes(HMR_RUNTIME_IMPORT)) {
-		return new Response(html, {
-			status: response.status,
-			statusText: response.statusText,
-			headers: response.headers,
-		});
-	}
-
-	const updatedHtml = html.replace(/<\/html>/i, `${HMR_RUNTIME_SCRIPT}</html>`);
-	const headers = new Headers(response.headers);
-	headers.delete('Content-Length');
-
-	return new Response(updatedHtml, {
-		status: response.status,
-		statusText: response.statusText,
-		headers,
-	});
-}

package/src/adapters/shared/hmr-manager.contract.test.ts

@@ -1,228 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, test, vi } from 'vitest';
-import { ConfigBuilder } from '../../config/config-builder.ts';
-import { resolveInternalWorkDir } from '../../utils/resolve-work-dir.ts';
-import { NodeHmrManager } from '../node/node-hmr-manager.ts';
-import { HmrManager as BunHmrManager } from '../bun/hmr-manager.ts';
-
-type SharedHmrManager = {
-	handleFileChange(filePath: string, options?: { broadcast?: boolean }): Promise<void>;
-	registerEntrypoint(entrypointPath: string): Promise<string>;
-	registerScriptEntrypoint(entrypointPath: string): Promise<string>;
-	getWatchedFiles(): Map<string, string>;
-	stop(): void;
-	appConfig: Awaited<ReturnType<ConfigBuilder['build']>>;
-};
-
-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 });
-	}
-	vi.restoreAllMocks();
-});
-
-const runtimes = [
-	{
-		name: 'node',
-		async create(rootDir: string): Promise<SharedHmrManager> {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return new NodeHmrManager({
-				appConfig: config,
-				bridge: {
-					subscriberCount: 0,
-					broadcast: () => {},
-				} as any,
-			});
-		},
-	},
-	{
-		name: 'bun',
-		async create(rootDir: string): Promise<SharedHmrManager> {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return new BunHmrManager({
-				appConfig: config,
-				bridge: {
-					subscriberCount: 0,
-					broadcast: () => {},
-					subscribe: () => {},
-					unsubscribe: () => {},
-				} as any,
-			});
-		},
-	},
-] as const;
-
-function getEntrypointOutputPath(manager: SharedHmrManager, entrypointPath: string): string {
-	const relativePathJs = path
-		.relative(manager.appConfig.absolutePaths.srcDir, entrypointPath)
-		.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
-	const encodedPathJs = relativePathJs.replace(/\[([^\]]+)\]/g, '_$1_');
-	return path.join(resolveInternalWorkDir(manager.appConfig), 'assets', '_hmr', encodedPathJs);
-}
-
-describe.each(runtimes)('shared HMR manager contract: $name', ({ create }) => {
-	test('shares one in-flight entrypoint registration across concurrent callers', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-register');
-		const pagesDir = path.join(rootDir, 'src', 'pages');
-		fs.mkdirSync(pagesDir, { recursive: true });
-
-		const entrypointPath = path.join(pagesDir, 'react-lab.tsx');
-		fs.writeFileSync(entrypointPath, 'export default function Page() { return null; }', 'utf8');
-
-		const manager = await create(rootDir);
-		const outputPath = getEntrypointOutputPath(manager, entrypointPath);
-
-		const handleFileChange = vi.spyOn(manager, 'handleFileChange').mockImplementation(async () => {
-			await new Promise((resolve) => setTimeout(resolve, 25));
-			fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-			fs.writeFileSync(outputPath, 'export default 1;', 'utf8');
-		});
-
-		const [firstUrl, secondUrl] = await Promise.all([
-			manager.registerEntrypoint(entrypointPath),
-			manager.registerEntrypoint(entrypointPath),
-		]);
-
-		assert.equal(firstUrl, '/assets/_hmr/pages/react-lab.js');
-		assert.equal(secondUrl, '/assets/_hmr/pages/react-lab.js');
-		assert.equal(handleFileChange.mock.calls.length, 1);
-
-		manager.stop();
-	});
-
-	test('fails strict page registration when no integration emits output', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-strict-fail');
-		const pagesDir = path.join(rootDir, 'src', 'pages');
-		fs.mkdirSync(pagesDir, { recursive: true });
-
-		const entrypointPath = path.join(pagesDir, 'react-content.mdx');
-		fs.writeFileSync(entrypointPath, '# Hello', 'utf8');
-
-		const manager = await create(rootDir);
-		vi.spyOn(manager, 'handleFileChange').mockImplementation(async () => {});
-
-		await assert.rejects(() => manager.registerEntrypoint(entrypointPath), /Integration failed to emit entrypoint/);
-		assert.equal(manager.getWatchedFiles().has(path.resolve(entrypointPath)), false);
-
-		manager.stop();
-	});
-
-	test('uses the generic build path for explicit script entrypoints', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-script-register');
-		const srcDir = path.join(rootDir, 'src');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entrypointPath = path.join(srcDir, 'script.ts');
-		fs.writeFileSync(entrypointPath, 'console.log("hello");', 'utf8');
-
-		const manager = await create(rootDir);
-		const outputPath = path.join(resolveInternalWorkDir(manager.appConfig), 'assets', '_hmr', 'script.js');
-		const buildCalls: string[] = [];
-		manager.appConfig.runtime!.buildExecutor = {
-			build: vi.fn(async (options) => {
-				buildCalls.push(options.entrypoints[0] as string);
-				fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-				fs.writeFileSync(outputPath, 'fresh-output', 'utf8');
-				return {
-					success: true,
-					logs: [],
-					outputs: [{ path: outputPath }],
-				};
-			}),
-		};
-
-		const outputUrl = await manager.registerScriptEntrypoint(entrypointPath);
-
-		assert.equal(outputUrl, '/assets/_hmr/script.js');
-		assert.deepEqual(buildCalls, [entrypointPath]);
-		assert.equal(fs.readFileSync(outputPath, 'utf8'), 'fresh-output');
-
-		manager.stop();
-	});
-
-	test('registering one script entrypoint does not rebuild previously watched script entrypoints', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-script-targeted-register');
-		const srcDir = path.join(rootDir, 'src');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const firstEntrypoint = path.join(srcDir, 'first.script.ts');
-		const secondEntrypoint = path.join(srcDir, 'second.script.ts');
-		fs.writeFileSync(firstEntrypoint, 'console.log("first");', 'utf8');
-		fs.writeFileSync(secondEntrypoint, 'console.log("second");', 'utf8');
-
-		const manager = await create(rootDir);
-		const buildCalls: string[][] = [];
-		manager.appConfig.runtime!.buildExecutor = {
-			build: vi.fn(async (options) => {
-				const entrypoints = (options.entrypoints as string[]).map(String);
-				buildCalls.push(entrypoints);
-				for (const entrypoint of entrypoints) {
-					const relativePathJs = path
-						.relative(path.join(rootDir, 'src'), entrypoint)
-						.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
-					const outputPath = path.join(
-						resolveInternalWorkDir(manager.appConfig),
-						'assets',
-						'_hmr',
-						relativePathJs,
-					);
-					fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-					fs.writeFileSync(outputPath, `output:${path.basename(entrypoint)}`, 'utf8');
-				}
-				return {
-					success: true,
-					logs: [],
-					outputs: entrypoints.map((entrypoint) => ({
-						path: path.join(
-							resolveInternalWorkDir(manager.appConfig),
-							'assets',
-							'_hmr',
-							path.relative(path.join(rootDir, 'src'), entrypoint).replace(/\.(tsx?|jsx?|mdx?)$/, '.js'),
-						),
-					})),
-				};
-			}),
-		};
-
-		await manager.registerScriptEntrypoint(firstEntrypoint);
-		await manager.registerScriptEntrypoint(secondEntrypoint);
-
-		assert.deepEqual(buildCalls, [[firstEntrypoint], [secondEntrypoint]]);
-
-		manager.stop();
-	});
-
-	test('stop clears retained registration state', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-stop');
-		const pagesDir = path.join(rootDir, 'src', 'pages');
-		fs.mkdirSync(pagesDir, { recursive: true });
-
-		const entrypointPath = path.join(pagesDir, 'react-content.tsx');
-		fs.writeFileSync(entrypointPath, 'export default function Page() { return null; }', 'utf8');
-
-		const manager = await create(rootDir);
-		const outputPath = getEntrypointOutputPath(manager, entrypointPath);
-
-		vi.spyOn(manager, 'handleFileChange').mockImplementation(async () => {
-			fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-			fs.writeFileSync(outputPath, 'export default 1;', 'utf8');
-		});
-
-		await manager.registerEntrypoint(entrypointPath);
-
-		manager.stop();
-
-		assert.equal(manager.getWatchedFiles().size, 0);
-	});
-});