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

package/src/adapters/node/node-client-bridge.test.ts

@@ -0,0 +1,198 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { NodeClientBridge } from './node-client-bridge.ts';
+
+// ---------------------------------------------------------------------------
+// Minimal WebSocket mock — only the surface that NodeClientBridge touches
+// ---------------------------------------------------------------------------
+function createMockWs(readyState = 1 /* OPEN */) {
+	return {
+		readyState,
+		send: vi.fn(),
+		ping: vi.fn(),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('NodeClientBridge', () => {
+	let bridge: NodeClientBridge;
+
+	beforeEach(() => {
+		vi.useFakeTimers();
+		bridge = new NodeClientBridge();
+	});
+
+	afterEach(() => {
+		bridge.destroy();
+		vi.useRealTimers();
+	});
+
+	// ── subscribe / unsubscribe ─────────────────────────────────────────────
+
+	describe('subscribe / unsubscribe', () => {
+		it('increments subscriberCount when a socket is added', () => {
+			const ws = createMockWs();
+			bridge.subscribe(ws as never);
+			expect(bridge.subscriberCount).toBe(1);
+		});
+
+		it('decrements subscriberCount when a socket is removed', () => {
+			const ws = createMockWs();
+			bridge.subscribe(ws as never);
+			bridge.unsubscribe(ws as never);
+			expect(bridge.subscriberCount).toBe(0);
+		});
+
+		it('handles unsubscribing a socket that was never added', () => {
+			const ws = createMockWs();
+			expect(() => bridge.unsubscribe(ws as never)).not.toThrow();
+		});
+	});
+
+	// ── broadcast ──────────────────────────────────────────────────────────
+
+	describe('broadcast', () => {
+		it('sends the serialised event to all OPEN subscribers', () => {
+			const ws1 = createMockWs(1);
+			const ws2 = createMockWs(1);
+			bridge.subscribe(ws1 as never);
+			bridge.subscribe(ws2 as never);
+
+			bridge.broadcast({ type: 'reload' });
+
+			expect(ws1.send).toHaveBeenCalledWith(JSON.stringify({ type: 'reload' }));
+			expect(ws2.send).toHaveBeenCalledWith(JSON.stringify({ type: 'reload' }));
+		});
+
+		it('does NOT send to a socket that is not OPEN (readyState !== 1)', () => {
+			const closedWs = createMockWs(3 /* CLOSED */);
+			bridge.subscribe(closedWs as never);
+
+			bridge.broadcast({ type: 'reload' });
+
+			expect(closedWs.send).not.toHaveBeenCalled();
+		});
+	});
+
+	// ── convenience helpers ────────────────────────────────────────────────
+
+	describe('convenience broadcast helpers', () => {
+		it('reload() broadcasts a reload event', () => {
+			const ws = createMockWs();
+			bridge.subscribe(ws as never);
+
+			bridge.reload();
+
+			expect(ws.send).toHaveBeenCalledWith(JSON.stringify({ type: 'reload' }));
+		});
+
+		it('cssUpdate() broadcasts a css-update event with path and timestamp', () => {
+			const ws = createMockWs();
+			bridge.subscribe(ws as never);
+
+			bridge.cssUpdate('/styles/main.css');
+
+			const payload = JSON.parse((ws.send as ReturnType<typeof vi.fn>).mock.calls[0][0]);
+			expect(payload.type).toBe('css-update');
+			expect(payload.path).toBe('/styles/main.css');
+			expect(typeof payload.timestamp).toBe('number');
+		});
+
+		it('update() broadcasts an update event with path and timestamp', () => {
+			const ws = createMockWs();
+			bridge.subscribe(ws as never);
+
+			bridge.update('/pages/index.ts');
+
+			const payload = JSON.parse((ws.send as ReturnType<typeof vi.fn>).mock.calls[0][0]);
+			expect(payload.type).toBe('update');
+			expect(payload.path).toBe('/pages/index.ts');
+		});
+
+		it('error() broadcasts an error event with the message', () => {
+			const ws = createMockWs();
+			bridge.subscribe(ws as never);
+
+			bridge.error('build failed');
+
+			expect(ws.send).toHaveBeenCalledWith(JSON.stringify({ type: 'error', message: 'build failed' }));
+		});
+	});
+
+	// ── heartbeat sweep ────────────────────────────────────────────────────
+
+	describe('heartbeat sweep (every 30 s)', () => {
+		it('pings OPEN subscribers on each sweep', () => {
+			const ws = createMockWs(1);
+			bridge.subscribe(ws as never);
+
+			vi.advanceTimersByTime(30_000);
+
+			expect(ws.ping).toHaveBeenCalledTimes(1);
+		});
+
+		it('removes zombie sockets (non-OPEN) from the subscriber set', () => {
+			const liveWs = createMockWs(1 /* OPEN */);
+			const deadWs = createMockWs(3 /* CLOSED */);
+			bridge.subscribe(liveWs as never);
+			bridge.subscribe(deadWs as never);
+
+			expect(bridge.subscriberCount).toBe(2);
+
+			vi.advanceTimersByTime(30_000);
+
+			expect(bridge.subscriberCount).toBe(1);
+			expect(liveWs.ping).toHaveBeenCalledTimes(1);
+			expect(deadWs.ping).not.toHaveBeenCalled();
+		});
+
+		it('accumulates cleanup across multiple sweeps', () => {
+			const ws1 = createMockWs(1);
+			bridge.subscribe(ws1 as never);
+
+			// First sweep – still alive
+			vi.advanceTimersByTime(30_000);
+			expect(bridge.subscriberCount).toBe(1);
+
+			// Socket goes away
+			ws1.readyState = 3;
+
+			// Second sweep – removed
+			vi.advanceTimersByTime(30_000);
+			expect(bridge.subscriberCount).toBe(0);
+		});
+	});
+
+	// ── destroy ────────────────────────────────────────────────────────────
+
+	describe('destroy()', () => {
+		it('stops the heartbeat timer so no further pings are sent', () => {
+			const ws = createMockWs(1);
+			bridge.subscribe(ws as never);
+
+			bridge.destroy();
+
+			// Advancing time should NOT trigger any sweep
+			vi.advanceTimersByTime(30_000 * 5);
+
+			expect(ws.ping).not.toHaveBeenCalled();
+		});
+
+		it('clears all subscribers', () => {
+			bridge.subscribe(createMockWs() as never);
+			bridge.subscribe(createMockWs() as never);
+
+			bridge.destroy();
+
+			expect(bridge.subscriberCount).toBe(0);
+		});
+
+		it('is safe to call destroy() multiple times', () => {
+			expect(() => {
+				bridge.destroy();
+				bridge.destroy();
+			}).not.toThrow();
+		});
+	});
+});

package/src/adapters/node/node-client-bridge.ts

@@ -0,0 +1,79 @@
+import type { WebSocket } from 'ws';
+import type { ClientBridgeEvent, IClientBridge } from '../../types/public-types.ts';
+
+const HEARTBEAT_INTERVAL_MS = 30_000;
+
+export class NodeClientBridge implements IClientBridge {
+	private subscribers = new Set<WebSocket>();
+	private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+
+	constructor() {
+		this.heartbeatTimer = setInterval(() => this.sweep(), HEARTBEAT_INTERVAL_MS);
+		/* Allow the process to exit even if the timer is still active */
+		this.heartbeatTimer.unref?.();
+	}
+
+	/**
+	 * Pings all open subscribers and removes any that are no longer in OPEN state.
+	 * This prevents a slow memory leak caused by zombie connections that never
+	 * send a close event (e.g. abruptly killed browsers, orphaned tabs, network drops).
+	 */
+	private sweep(): void {
+		for (const ws of this.subscribers) {
+			if (ws.readyState !== 1 /* OPEN */) {
+				this.subscribers.delete(ws);
+				continue;
+			}
+			ws.ping();
+		}
+	}
+
+	subscribe(ws: WebSocket): void {
+		this.subscribers.add(ws);
+	}
+
+	unsubscribe(ws: WebSocket): void {
+		this.subscribers.delete(ws);
+	}
+
+	broadcast(event: ClientBridgeEvent): void {
+		const payload = JSON.stringify(event);
+		for (const ws of this.subscribers) {
+			if (ws.readyState === 1) {
+				ws.send(payload);
+			}
+		}
+	}
+
+	reload(): void {
+		this.broadcast({ type: 'reload' });
+	}
+
+	cssUpdate(path: string): void {
+		this.broadcast({ type: 'css-update', path, timestamp: Date.now() });
+	}
+
+	update(path: string): void {
+		this.broadcast({ type: 'update', path, timestamp: Date.now() });
+	}
+
+	error(message: string): void {
+		this.broadcast({ type: 'error', message });
+	}
+
+	get subscriberCount(): number {
+		return this.subscribers.size;
+	}
+
+	/**
+	 * Stops the heartbeat timer and clears all subscribers.
+	 * Call this when the dev server is shutting down.
+	 */
+	destroy(): void {
+		if (this.heartbeatTimer !== null) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = null;
+		}
+		this.subscribers.clear();
+	}
+}

package/src/adapters/node/node-hmr-manager.test.ts

@@ -0,0 +1,374 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, test, vi } from 'vitest';
+import { ConfigBuilder } from '../../config/config-builder.ts';
+import { resolveInternalExecutionDir, resolveInternalWorkDir } from '../../utils/resolve-work-dir.ts';
+import { NodeHmrManager } from './node-hmr-manager.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 });
+	}
+	vi.restoreAllMocks();
+});
+
+test('NodeHmrManager shares one in-flight entrypoint registration across concurrent callers', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-register');
+	const srcDir = path.join(rootDir, 'src');
+	const pagesDir = path.join(srcDir, '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 config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 0,
+			broadcast: () => {},
+		} as any,
+	});
+
+	const relativePathJs = path
+		.relative(config.absolutePaths.srcDir, entrypointPath)
+		.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
+	const encodedPathJs = relativePathJs.replace(/\[([^\]]+)\]/g, '_$1_');
+	const outputPath = path.join(resolveInternalWorkDir(config), 'assets', '_hmr', encodedPathJs);
+
+	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);
+	assert.equal(fs.existsSync(outputPath), true);
+
+	manager.stop();
+});
+
+test('NodeHmrManager does not broadcast HMR events for initial entrypoint registration builds', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-silent-register');
+	const srcDir = path.join(rootDir, 'src');
+	const pagesDir = path.join(srcDir, '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 broadcast = vi.fn();
+	const config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 1,
+			broadcast,
+		} as any,
+	});
+
+	const relativePathJs = path
+		.relative(config.absolutePaths.srcDir, entrypointPath)
+		.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
+	const encodedPathJs = relativePathJs.replace(/\[([^\]]+)\]/g, '_$1_');
+	const outputPath = path.join(resolveInternalWorkDir(config), 'assets', '_hmr', encodedPathJs);
+
+	vi.spyOn(manager, 'handleFileChange').mockImplementation(async (_filePath, _options) => {
+		fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+		fs.writeFileSync(outputPath, 'export default 1;', 'utf8');
+	});
+
+	const outputUrl = await manager.registerEntrypoint(entrypointPath);
+
+	assert.equal(outputUrl, '/assets/_hmr/pages/react-content.js');
+	assert.equal(broadcast.mock.calls.length, 0);
+
+	manager.stop();
+});
+
+test('NodeHmrManager clears timed-out entrypoint registrations so later requests can retry', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-timeout-register');
+	const srcDir = path.join(rootDir, 'src');
+	const pagesDir = path.join(srcDir, 'pages');
+	fs.mkdirSync(pagesDir, { recursive: true });
+
+	const entrypointPath = path.join(pagesDir, 'stuck-page.tsx');
+	fs.writeFileSync(entrypointPath, 'export default function Page() { return null; }', 'utf8');
+
+	const config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 0,
+			broadcast: () => {},
+		} as any,
+	});
+
+	const previousNodeEnv = process.env.NODE_ENV;
+	process.env.NODE_ENV = 'development';
+
+	const handleFileChange = vi.spyOn(manager, 'handleFileChange').mockImplementation(async () => {
+		await new Promise(() => undefined);
+	});
+
+	try {
+		await assert.rejects(() => manager.registerEntrypoint(entrypointPath), /Timed out registering entrypoint/);
+
+		const registrations = (manager as unknown as { entrypointRegistrations: Map<string, Promise<string>> })
+			.entrypointRegistrations;
+		const watchedFiles = manager.getWatchedFiles();
+		assert.equal(registrations.size, 0);
+		assert.equal(watchedFiles.has(entrypointPath), false);
+
+		handleFileChange.mockImplementationOnce(async () => {
+			const relativePathJs = path
+				.relative(config.absolutePaths.srcDir, entrypointPath)
+				.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
+			const encodedPathJs = relativePathJs.replace(/\[([^\]]+)\]/g, '_$1_');
+			const outputPath = path.join(resolveInternalWorkDir(config), 'assets', '_hmr', encodedPathJs);
+			fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+			fs.writeFileSync(outputPath, 'export default 2;', 'utf8');
+		});
+
+		const retriedUrl = await manager.registerEntrypoint(entrypointPath);
+		assert.equal(retriedUrl, '/assets/_hmr/pages/stuck-page.js');
+		assert.equal(watchedFiles.get(entrypointPath), retriedUrl);
+	} finally {
+		process.env.NODE_ENV = previousNodeEnv;
+		manager.stop();
+	}
+});
+
+test('NodeHmrManager fails strict entrypoint registration when the owning integration emits no output', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-strict-fail');
+	const srcDir = path.join(rootDir, 'src');
+	const pagesDir = path.join(srcDir, 'pages');
+	fs.mkdirSync(pagesDir, { recursive: true });
+
+	const entrypointPath = path.join(pagesDir, 'react-content.mdx');
+	fs.writeFileSync(entrypointPath, '# Hello', 'utf8');
+
+	const config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 0,
+			broadcast: () => {},
+		} as any,
+	});
+
+	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('NodeHmrManager uses the generic build path for script entrypoints when no strategy emits output', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-script-fallback');
+	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 config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 0,
+			broadcast: () => {},
+		} as any,
+	});
+
+	const relativePathJs = path
+		.relative(config.absolutePaths.srcDir, entrypointPath)
+		.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
+	const outputPath = path.join(resolveInternalWorkDir(config), 'assets', '_hmr', relativePathJs);
+
+	const buildCalls: string[] = [];
+	config.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('NodeHmrManager disables HMR instead of throwing when runtime bundle generation crashes', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-runtime-failure');
+	const config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 0,
+			broadcast: () => {},
+		} as any,
+	});
+	const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+	let runtimeEntrypoint: string | undefined;
+
+	vi.spyOn(
+		(
+			manager as unknown as {
+				browserBundleService: { bundle: (options: { entrypoints: string[] }) => Promise<unknown> };
+			}
+		).browserBundleService,
+		'bundle',
+	).mockImplementationOnce(async (options: { entrypoints: string[] }) => {
+		runtimeEntrypoint = options.entrypoints[0];
+		throw new Error('Unexpected end of JSON input');
+	});
+
+	await assert.doesNotReject(() => manager.buildRuntime());
+	assert.equal(manager.isEnabled(), false);
+	assert.equal(runtimeEntrypoint, fileURLToPath(import.meta.resolve('@ecopages/core/hmr/client/hmr-runtime')));
+	assert.equal(runtimeEntrypoint?.includes(`${path.sep}.eco${path.sep}hmr${path.sep}client${path.sep}`), false);
+
+	manager.stop();
+	errorSpy.mockRestore();
+});
+
+test('NodeHmrManager ignores deleted watched entrypoints and clears stale registration state', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-missing-file');
+	const srcDir = path.join(rootDir, 'src');
+	const pagesDir = path.join(srcDir, 'pages');
+	fs.mkdirSync(pagesDir, { recursive: true });
+
+	const entrypointPath = path.join(pagesDir, 'deleted-page.tsx');
+	fs.writeFileSync(entrypointPath, 'export default function Page() { return null; }', 'utf8');
+
+	const config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 0,
+			broadcast: () => {},
+		} as any,
+	});
+
+	const outputUrl = '/assets/_hmr/pages/deleted-page.js';
+	manager.getWatchedFiles().set(entrypointPath, outputUrl);
+	const clearDependencies = vi.spyOn(
+		(
+			manager as unknown as {
+				entrypointDependencyGraph: { clearEntrypointDependencies: (entrypoint: string) => void };
+			}
+		).entrypointDependencyGraph,
+		'clearEntrypointDependencies',
+	);
+	const strategyMatches = vi.spyOn(
+		(manager as unknown as { strategies: Array<{ matches: (filePath: string) => boolean }> }).strategies[0]!,
+		'matches',
+	);
+
+	fs.rmSync(entrypointPath);
+
+	await assert.doesNotReject(() => manager.handleFileChange(entrypointPath));
+	assert.equal(manager.getWatchedFiles().has(entrypointPath), false);
+	assert.deepEqual(clearDependencies.mock.calls, [[entrypointPath]]);
+	assert.equal(strategyMatches.mock.calls.length, 0);
+
+	manager.stop();
+});
+
+test('NodeHmrManager stop clears retained registration state', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-stop-cleanup');
+	const srcDir = path.join(rootDir, 'src');
+	const pagesDir = path.join(srcDir, '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 config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 0,
+			broadcast: () => {},
+		} as any,
+	});
+
+	const relativePathJs = path
+		.relative(config.absolutePaths.srcDir, entrypointPath)
+		.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
+	const encodedPathJs = relativePathJs.replace(/\[([^\]]+)\]/g, '_$1_');
+	const outputPath = path.join(resolveInternalWorkDir(config), 'assets', '_hmr', encodedPathJs);
+
+	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);
+	assert.equal(config.runtime?.entrypointDependencyGraph?.getDependencyEntrypoints(entrypointPath).size, 0);
+});
+
+test('NodeHmrManager keeps internal browser and server-module outputs out of distDir', async () => {
+	const rootDir = createTempRoot('ecopages-node-hmr-internal-paths');
+	const config = await new ConfigBuilder().setRootDir(rootDir).build();
+	const manager = new NodeHmrManager({
+		appConfig: config,
+		bridge: {
+			subscriberCount: 0,
+			broadcast: () => {},
+		} as any,
+	});
+
+	assert.equal(manager.getDistDir(), path.join(resolveInternalWorkDir(config), 'assets', '_hmr'));
+
+	const importModule = vi.fn(async (_options: { outdir: string }) => ({}));
+	(manager as unknown as { serverModuleTranspiler: { importModule: typeof importModule } }).serverModuleTranspiler = {
+		importModule,
+	};
+
+	await manager.getDefaultContext().importServerModule(path.join(config.absolutePaths.srcDir, 'pages', 'index.tsx'));
+
+	assert.equal(
+		importModule.mock.calls[0]?.[0]?.outdir,
+		path.join(resolveInternalExecutionDir(config), '.server-modules'),
+	);
+
+	manager.stop();
+});