npm - @ecopages/core - Versions diffs - 0.2.0-alpha.7 → 0.2.0-alpha.8 - Mend

@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (354) hide show

package/src/adapters/shared/fs-server-response-factory.test.ts DELETED Viewed

@@ -1,187 +0,0 @@
-import { beforeAll, describe, expect, it, vi } from 'vitest';
-import {
-	FIXTURE_APP_PROJECT_DIR,
-	FIXTURE_EXISTING_CSS_FILE_IN_DIST,
-	FIXTURE_EXISTING_SVG_FILE_IN_DIST_PATH,
-} from '../../../__fixtures__/constants.js';
-import { appLogger } from '../../global/app-logger.ts';
-import { ConfigBuilder } from '../../config/config-builder.ts';
-import { STATUS_MESSAGE } from '../../constants.ts';
-import { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
-import { FileSystemServerResponseFactory } from './fs-server-response-factory.ts';
-let appConfig: Awaited<ReturnType<ConfigBuilder['build']>>;
-let responseFactory: FileSystemServerResponseFactory;
-describe('FileSystemServerResponseFactory', () => {
-	beforeAll(async () => {
-		appConfig = await new ConfigBuilder().setRootDir(FIXTURE_APP_PROJECT_DIR).build();
-		for (const integration of appConfig.integrations) {
-			integration.setConfig(appConfig);
-			integration.setRuntimeOrigin(appConfig.baseUrl);
-		}
-		responseFactory = new FileSystemServerResponseFactory({
-			appConfig,
-			routeRendererFactory: new RouteRendererFactory({
-				appConfig,
-				runtimeOrigin: appConfig.baseUrl,
-			}),
-			options: {
-				watchMode: false,
-			},
-		});
-	});
-	describe('isHtml', () => {
-		it('should return true for text/html content type', () => {
-			const result = responseFactory.isHtml('text/html');
-			expect(result).toBe(true);
-		});
-		it('should return false for text/plain content type', () => {
-			const result = responseFactory.isHtml('text/plain');
-			expect(result).toBe(false);
-		});
-		it('should return false for other content types', () => {
-			const result = responseFactory.isHtml('application/json');
-			expect(result).toBe(false);
-		});
-	});
-	describe('shouldEnableGzip', () => {
-		it('should return false in watch mode', () => {
-			const responseFactoryWatch = new FileSystemServerResponseFactory({
-				appConfig,
-				routeRendererFactory: new RouteRendererFactory({
-					appConfig,
-					runtimeOrigin: appConfig.baseUrl,
-				}),
-				options: {
-					watchMode: true,
-				},
-			});
-			const result = responseFactoryWatch.shouldEnableGzip('text/javascript');
-			expect(result).toBe(false);
-		});
-		it('should return true for text/javascript content type', () => {
-			const result = responseFactory.shouldEnableGzip('text/javascript');
-			expect(result).toBe(true);
-		});
-		it('should return true for text/css content type', () => {
-			const result = responseFactory.shouldEnableGzip('text/css');
-			expect(result).toBe(true);
-		});
-		it('should return false for other content types', () => {
-			const result = responseFactory.shouldEnableGzip('application/json');
-			expect(result).toBe(false);
-		});
-	});
-	describe('createResponseWithBody', () => {
-		it('should create a response with the given route renderer body', async () => {
-			const routeRendererBody = '<html><body>Test</body></html>';
-			const response = await responseFactory.createResponseWithBody(routeRendererBody);
-			const body = await response.text();
-			expect(body).toBe(routeRendererBody);
-			expect(response.headers.get('Content-Type')).toBe('text/html');
-		});
-	});
-	describe('createDefaultNotFoundResponse', () => {
-		it('should create a response with status 404 and body "file not found"', async () => {
-			const response = await responseFactory.createDefaultNotFoundResponse();
-			expect(response.status).toBe(404);
-			expect(await response.text()).toBe(STATUS_MESSAGE[404]);
-		});
-	});
-	describe('createCustomNotFoundResponse', () => {
-		it('should create a response with status 404 if error404 template file does not exist', async () => {
-			const customAppConfig = {
-				...appConfig,
-				absolutePaths: {
-					...appConfig.absolutePaths,
-					error404TemplatePath: 'non-existent-file',
-				},
-			};
-			const responseFactoryNo404Template = new FileSystemServerResponseFactory({
-				appConfig: customAppConfig,
-				routeRendererFactory: new RouteRendererFactory({
-					appConfig: customAppConfig,
-					runtimeOrigin: customAppConfig.baseUrl,
-				}),
-				options: {
-					watchMode: false,
-				},
-			});
-			const response = await responseFactoryNo404Template.createCustomNotFoundResponse();
-			expect(response.status).toBe(404);
-			expect(await response.text()).toBe(STATUS_MESSAGE[404]);
-		});
-		it('should create a response with the route renderer body if error404 template file exists', async () => {
-			const response = await responseFactory.createCustomNotFoundResponse();
-			const body = await response.text();
-			expect(body).toContain('<h1>404 - Page Not Found</h1>');
-			expect(response.headers.get('Content-Type')).toBe('text/html');
-			expect(response.status).toBe(404);
-		});
-	});
-	describe('createFileResponse', () => {
-		it('should create a response with the file content and content type', async () => {
-			const response = await responseFactory.createFileResponse(
-				FIXTURE_EXISTING_SVG_FILE_IN_DIST_PATH,
-				'image/svg+xml',
-			);
-			expect(response.headers.get('Content-Type')).toBe('image/svg+xml');
-		});
-		it('should return custom 404 page if the file does not exist', async () => {
-			const response = await responseFactory.createFileResponse('/path/to/nonexistent.txt', 'text/plain');
-			const body = await response.text();
-			expect(body).toContain('<h1>404 - Page Not Found</h1>');
-			expect(response.status).toBe(404);
-		});
-		it('should log debug for ENOENT errors', async () => {
-			const debugSpy = vi.spyOn(appLogger, 'debug');
-			const errorSpy = vi.spyOn(appLogger, 'error');
-			await responseFactory.createFileResponse('/path/to/nonexistent-debug.txt', 'text/plain');
-			expect(debugSpy).toHaveBeenCalled();
-			expect(errorSpy).not.toHaveBeenCalled();
-			debugSpy.mockRestore();
-			errorSpy.mockRestore();
-		});
-		it('should serve gzip file with Content-Encoding header when gzip is enabled', async () => {
-			const cssFilePath = `${appConfig.absolutePaths.distDir}/${FIXTURE_EXISTING_CSS_FILE_IN_DIST}`;
-			const response = await responseFactory.createFileResponse(cssFilePath, 'text/css');
-			expect(response.headers.get('Content-Type')).toBe('text/css');
-			expect(response.headers.get('Content-Encoding')).toBe('gzip');
-		});
-		it('should not set Content-Encoding header for non-gzip content types', async () => {
-			const response = await responseFactory.createFileResponse(
-				FIXTURE_EXISTING_SVG_FILE_IN_DIST_PATH,
-				'image/svg+xml',
-			);
-			expect(response.headers.get('Content-Type')).toBe('image/svg+xml');
-			expect(response.headers.get('Content-Encoding')).toBeNull();
-		});
-	});
-});

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

@@ -1,286 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-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 '../../internal-types.ts';
-import { RouteRendererFactory } from '../../route-renderer/route-renderer.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 { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.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 scanner = new FSRouterScanner({
-	dir: path.join(appConfig.rootDir, appConfig.srcDir, appConfig.pagesDir),
-	appConfig,
-	origin: appConfig.baseUrl,
-	templatesExt: appConfig.templatesExt,
-	options: {
-		buildMode: false,
-	},
-});
-const router = new FSRouter({
-	origin: appConfig.baseUrl,
-	assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
-	scanner,
-});
-const routeRendererFactory = new RouteRendererFactory({
-	appConfig,
-	runtimeOrigin: appConfig.baseUrl,
-});
-const fileSystemResponseFactory = new FileSystemServerResponseFactory({
-	appConfig,
-	routeRendererFactory,
-	options: {
-		watchMode: false,
-	},
-});
-describe('FileSystemResponseMatcher', () => {
-	describe('without cache service', () => {
-		const matcherWithoutCache = new FileSystemResponseMatcher({
-			appConfig,
-			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 = {
-				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,
-			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 = {
-				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 = {
-				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 = {
-				kind: 'exact',
-				pathname: '/path-a',
-				filePath: INDEX_TEMPLATE_FILE,
-				params: {},
-				query: {},
-			};
-			const match2: MatchResult = {
-				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 = {
-				kind: 'exact',
-				pathname: basePath,
-				filePath: INDEX_TEMPLATE_FILE,
-				params: {},
-				query: { q: 'test' },
-			};
-			const matchWithDifferentQuery: MatchResult = {
-				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,
-			router,
-			routeRendererFactory,
-			fileSystemResponseFactory,
-			cacheService,
-			defaultCacheStrategy: 'dynamic',
-		});
-		it('should bypass cache entirely for dynamic strategy', async () => {
-			const match: MatchResult = {
-				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,
-			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 response = await matcher.handleNoMatch('/robots.txt');
-			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 write page metadata modules to the execution directory', async () => {
-			const matcher = new FileSystemResponseMatcher({
-				appConfig,
-				router,
-				routeRendererFactory,
-				fileSystemResponseFactory,
-			});
-			const importModule = vi.fn(async () => ({}));
-			(matcher as any).serverModuleTranspiler = {
-				importModule,
-			};
-			await (matcher as any).importPageModule(INDEX_TEMPLATE_FILE);
-			expect(importModule).toHaveBeenCalledWith(
-				expect.objectContaining({
-					filePath: INDEX_TEMPLATE_FILE,
-					outdir: path.join(resolveInternalExecutionDir(appConfig), '.server-modules-meta'),
-				}),
-			);
-		});
-	});
-});

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

@@ -1,196 +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>;
-	registerSpecifierMap(map: Record<string, string>): void;
-	getWatchedFiles(): Map<string, string>;
-	getSpecifierMap(): Map<string, string>;
-	stop(): void;
-	appConfig: Awaited<ReturnType<ConfigBuilder['build']>>;
-	readonly runtimeName: string;
-};
-function withRuntimeName<T extends Omit<SharedHmrManager, 'runtimeName'>>(
-	manager: T,
-	runtimeName: SharedHmrManager['runtimeName'],
-): T & Pick<SharedHmrManager, 'runtimeName'> {
-	return Object.assign(manager, { runtimeName });
-}
-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 withRuntimeName(
-				new NodeHmrManager({
-					appConfig: config,
-					bridge: {
-						subscriberCount: 0,
-						broadcast: () => {},
-					} as any,
-				}),
-				'node',
-			);
-		},
-	},
-	{
-		name: 'bun',
-		async create(rootDir: string): Promise<SharedHmrManager> {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return withRuntimeName(
-				new BunHmrManager({
-					appConfig: config,
-					bridge: {
-						subscriberCount: 0,
-						broadcast: () => {},
-						subscribe: () => {},
-						unsubscribe: () => {},
-					} as any,
-				}),
-				'bun',
-			);
-		},
-	},
-] 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 }],
-				};
-			}),
-		};
-		vi.spyOn(manager, 'handleFileChange').mockImplementation(async () => {});
-		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('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');
-		});
-		manager.registerSpecifierMap({ react: '/assets/vendors/react.js' });
-		await manager.registerEntrypoint(entrypointPath);
-		manager.stop();
-		assert.equal(manager.getWatchedFiles().size, 0);
-		assert.equal(manager.getSpecifierMap().size, 0);
-	});
-});