@ecopages/core 0.2.0-alpha.24 → 0.2.0-alpha.26

package/src/build/build-adapter.test.ts

@@ -1,1240 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test, vi } from 'vitest';
-import {
-	build,
-	collectConfiguredAppBuildManifestContributions,
-	createConfiguredAppBuildManifest,
-	createBuildAdapter,
-	createBunBuildAdapter,
-	defaultBunBuildAdapter,
-	defaultBuildAdapter,
-	EsbuildBuildAdapter,
-	getAppBuildOwnership,
-	getAppBuildAdapter,
-	getAppBuildManifest,
-	getAppBrowserBuildPlugins,
-	getAppBuildExecutor,
-	getDefaultBuildAdapter,
-	getAppServerBuildPlugins,
-	setAppBuildAdapter,
-	setAppBuildOwnership,
-	setAppBuildManifest,
-	setupAppRuntimePlugins,
-	updateAppBuildManifest,
-	ViteHostBuildAdapter,
-} from './build-adapter.ts';
-import { createAppBuildManifest } from './build-manifest.ts';
-import type { EcoBuildPluginBuilder } from './build-types.ts';
-import { createAppBuildExecutor } from './dev-build-coordinator.ts';
-
-const tempRoots: string[] = [];
-
-function createTempRoot(prefix: string): string {
-	const root = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
-	tempRoots.push(root);
-	return root;
-}
-
-function cleanupTempRoots(): void {
-	for (const root of tempRoots.splice(0)) {
-		fs.rmSync(root, { recursive: true, force: true });
-	}
-}
-
-function clearNodeCssBridge(): void {
-	return;
-}
-
-test('defaultBuildAdapter remains the Bun-native fallback backed by the Bun adapter', () => {
-	assert.equal(defaultBuildAdapter, defaultBunBuildAdapter);
-	assert.ok(!(defaultBuildAdapter instanceof EsbuildBuildAdapter));
-	assert.equal(defaultBuildAdapter.ownership, 'bun-native');
-});
-
-test('createBuildAdapter makes Bun-native and Vite-host ownership explicit', () => {
-	const bunAdapter = createBuildAdapter({ ownership: 'bun-native' });
-	const viteAdapter = createBuildAdapter({ ownership: 'vite-host' });
-	const defaultViteAdapter = getDefaultBuildAdapter('vite-host');
-
-	assert.ok(!(bunAdapter instanceof EsbuildBuildAdapter));
-	assert.equal(bunAdapter.ownership, 'bun-native');
-	assert.ok(viteAdapter instanceof ViteHostBuildAdapter);
-	assert.equal(viteAdapter.ownership, 'vite-host');
-	assert.ok(defaultViteAdapter instanceof ViteHostBuildAdapter);
-	assert.equal(defaultViteAdapter.ownership, 'vite-host');
-});
-
-test('ViteHostBuildAdapter rejects core-owned execution attempts', async () => {
-	const adapter = new ViteHostBuildAdapter();
-
-	await assert.rejects(
-		adapter.build({
-			entrypoints: ['/tmp/entry.ts'],
-			root: '/tmp',
-			outdir: '/tmp/out',
-			target: 'browser',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-		}),
-		/Vite-hosted builds are owned by the host runtime/,
-	);
-	assert.throws(() => adapter.resolve('react', '/tmp'), /Vite-hosted builds are owned by the host runtime/);
-	assert.throws(
-		() => adapter.getTranspileOptions('browser-script'),
-		/Vite-hosted builds are owned by the host runtime/,
-	);
-});
-
-test('build helper accepts an explicit executor across package and relative build-adapter imports', async () => {
-	const packageBuildAdapter = await import('@ecopages/core/build/build-adapter');
-	const executor = {
-		build: vi.fn(async () => ({
-			success: true,
-			logs: [],
-			outputs: [{ path: '/tmp/shared.js' }],
-		})),
-	};
-
-	const result = await packageBuildAdapter.build(
-		{
-			entrypoints: ['/tmp/shared.ts'],
-			root: '/tmp',
-			outdir: '/tmp/out',
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-		},
-		executor,
-	);
-
-	assert.equal(result.success, true);
-	assert.deepEqual(result.outputs, [{ path: '/tmp/shared.js' }]);
-	assert.equal(executor.build.mock.calls.length, 1);
-});
-
-test('build helper uses the shared adapter when no executor is provided', async () => {
-	const executor = {
-		build: vi.fn(async () => ({
-			success: true,
-			logs: [],
-			outputs: [{ path: '/tmp/direct.js' }],
-		})),
-	};
-	const adapterSpy = vi.spyOn(defaultBuildAdapter, 'build').mockImplementation(executor.build);
-
-	const result = await build({
-		entrypoints: ['/tmp/direct.ts'],
-		root: '/tmp',
-		outdir: '/tmp/out',
-		target: 'node',
-		format: 'esm',
-		sourcemap: 'none',
-		splitting: false,
-		minify: false,
-	});
-
-	assert.equal(result.success, true);
-	assert.deepEqual(result.outputs, [{ path: '/tmp/direct.js' }]);
-	assert.equal(adapterSpy.mock.calls.length, 1);
-});
-
-test('BunBuildAdapter bundles entrypoints by default to keep transitive app imports in the emitted server module', async () => {
-	const originalBun = (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-	const buildCalls: Array<Record<string, unknown>> = [];
-
-	(globalThis as typeof globalThis & { Bun?: unknown }).Bun = {
-		build: vi.fn(async (options: Record<string, unknown>) => {
-			buildCalls.push(options);
-			return {
-				success: true,
-				logs: [],
-				outputs: [{ path: '/tmp/out/entry.js' }],
-			};
-		}),
-		hash: vi.fn(() => 1),
-		resolveSync: vi.fn((importPath: string) => importPath),
-	};
-
-	try {
-		const freshAdapter = createBunBuildAdapter();
-		const result = await freshAdapter.build({
-			entrypoints: ['/tmp/entry.ts'],
-			root: '/tmp',
-			outdir: '/tmp/out',
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: true,
-			minify: false,
-		});
-
-		assert.equal(result.success, true);
-		assert.equal(buildCalls.length, 1);
-		assert.equal(buildCalls[0]?.bundle, undefined);
-	} finally {
-		if (originalBun === undefined) {
-			delete (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-		} else {
-			(globalThis as typeof globalThis & { Bun?: unknown }).Bun = originalBun;
-		}
-	}
-});
-
-test('BunBuildAdapter normalizes hashed naming patterns to concrete emitted output files', async () => {
-	const originalBun = (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-
-	try {
-		const root = createTempRoot('ecopages-bun-naming-template');
-		const srcDir = path.join(root, 'src', 'components');
-		const outDir = path.join(root, 'dist', 'assets', 'components');
-		fs.mkdirSync(srcDir, { recursive: true });
-		fs.mkdirSync(outDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'kita-counter.script.ts');
-		fs.writeFileSync(entryPath, 'export const value = 1;');
-
-		const concreteOutputPath = path.join(outDir, 'kita-counter.script-abc123.js');
-		const placeholderOutputPath = path.join(outDir, 'kita-counter.script-[hash].js');
-
-		(globalThis as typeof globalThis & { Bun?: unknown }).Bun = {
-			build: vi.fn(async () => {
-				fs.writeFileSync(concreteOutputPath, 'export const value = 1;', 'utf8');
-				return {
-					success: true,
-					logs: [],
-					outputs: [{ path: placeholderOutputPath }],
-				};
-			}),
-			hash: vi.fn(() => 1),
-			resolveSync: vi.fn((importPath: string) => importPath),
-		};
-
-		const freshAdapter = createBunBuildAdapter();
-		const result = await freshAdapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'browser',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: true,
-			minify: false,
-			naming: '[name]-[hash].[ext]',
-		});
-
-		assert.equal(result.success, true);
-		assert.deepEqual(result.outputs, [{ path: concreteOutputPath }]);
-		assert.equal(fs.existsSync(concreteOutputPath), true);
-		assert.equal(fs.existsSync(placeholderOutputPath), false);
-	} finally {
-		if (originalBun === undefined) {
-			delete (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-		} else {
-			(globalThis as typeof globalThis & { Bun?: unknown }).Bun = originalBun;
-		}
-	}
-});
-
-test('BunBuildAdapter normalizes unordered multi-entrypoint outputs by path instead of output index', async () => {
-	const originalBun = (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-
-	try {
-		const root = createTempRoot('ecopages-bun-unordered-entrypoints');
-		const srcDir = path.join(root, 'src', 'components');
-		const outDir = path.join(root, 'dist', 'assets');
-		fs.mkdirSync(path.join(srcDir, 'theme-toggle'), { recursive: true });
-		fs.mkdirSync(path.join(srcDir, 'weather-app'), { recursive: true });
-		fs.mkdirSync(path.join(srcDir, 'code-tabs'), { recursive: true });
-		fs.mkdirSync(outDir, { recursive: true });
-
-		const themeToggleEntrypoint = path.join(srcDir, 'theme-toggle', 'theme-toggle.script.ts');
-		const weatherAppEntrypoint = path.join(srcDir, 'weather-app', 'weather-app.script.tsx');
-		const codeTabsEntrypoint = path.join(srcDir, 'code-tabs', 'code-tabs.script.tsx');
-		fs.writeFileSync(themeToggleEntrypoint, 'export const themeToggle = 1;');
-		fs.writeFileSync(weatherAppEntrypoint, 'export const weatherApp = 2;');
-		fs.writeFileSync(codeTabsEntrypoint, 'export const codeTabs = 3;');
-
-		const themeToggleOutput = path.join(outDir, 'components', 'theme-toggle', 'theme-toggle.script');
-		const weatherAppOutput = path.join(outDir, 'components', 'weather-app', 'weather-app.script');
-		const codeTabsOutput = path.join(outDir, 'components', 'code-tabs', 'code-tabs.script');
-
-		(globalThis as typeof globalThis & { Bun?: unknown }).Bun = {
-			build: vi.fn(async () => {
-				fs.mkdirSync(path.dirname(themeToggleOutput), { recursive: true });
-				fs.mkdirSync(path.dirname(weatherAppOutput), { recursive: true });
-				fs.mkdirSync(path.dirname(codeTabsOutput), { recursive: true });
-				fs.writeFileSync(themeToggleOutput, 'export const themeToggle = 1;', 'utf8');
-				fs.writeFileSync(weatherAppOutput, 'export const weatherApp = 2;', 'utf8');
-				fs.writeFileSync(codeTabsOutput, 'export const codeTabs = 3;', 'utf8');
-				return {
-					success: true,
-					logs: [],
-					outputs: [{ path: weatherAppOutput }, { path: codeTabsOutput }, { path: themeToggleOutput }],
-				};
-			}),
-			hash: vi.fn(() => 1),
-			resolveSync: vi.fn((importPath: string) => importPath),
-		};
-
-		const freshAdapter = createBunBuildAdapter();
-		const result = await freshAdapter.build({
-			entrypoints: [themeToggleEntrypoint, weatherAppEntrypoint, codeTabsEntrypoint],
-			root,
-			outdir: outDir,
-			outbase: path.join(root, 'src'),
-			target: 'browser',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: true,
-			minify: false,
-			naming: '[dir]/[name]',
-		});
-
-		assert.equal(result.success, true);
-		assert.deepEqual(result.outputs, [
-			{ path: `${weatherAppOutput}.js` },
-			{ path: `${codeTabsOutput}.js` },
-			{ path: `${themeToggleOutput}.js` },
-		]);
-		assert.equal(fs.readFileSync(`${themeToggleOutput}.js`, 'utf8'), 'export const themeToggle = 1;');
-		assert.equal(fs.readFileSync(`${weatherAppOutput}.js`, 'utf8'), 'export const weatherApp = 2;');
-		assert.equal(fs.readFileSync(`${codeTabsOutput}.js`, 'utf8'), 'export const codeTabs = 3;');
-	} finally {
-		if (originalBun === undefined) {
-			delete (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-		} else {
-			(globalThis as typeof globalThis & { Bun?: unknown }).Bun = originalBun;
-		}
-		cleanupTempRoots();
-	}
-});
-
-test('BunBuildAdapter matches reordered hashed multi-entrypoint outputs back to outbase-relative targets', async () => {
-	const originalBun = (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-
-	try {
-		const root = createTempRoot('ecopages-bun-unordered-hashed-entrypoints');
-		const srcDir = path.join(root, 'src', 'components');
-		const outDir = path.join(root, 'dist', 'assets');
-		fs.mkdirSync(path.join(srcDir, 'theme-toggle'), { recursive: true });
-		fs.mkdirSync(path.join(srcDir, 'weather-app'), { recursive: true });
-		fs.mkdirSync(outDir, { recursive: true });
-
-		const themeToggleEntrypoint = path.join(srcDir, 'theme-toggle', 'theme-toggle.script.ts');
-		const weatherAppEntrypoint = path.join(srcDir, 'weather-app', 'weather-app.script.tsx');
-		fs.writeFileSync(themeToggleEntrypoint, 'export const themeToggle = 1;');
-		fs.writeFileSync(weatherAppEntrypoint, 'export const weatherApp = 2;');
-
-		const themeToggleBunOutput = path.join(
-			outDir,
-			'src',
-			'components',
-			'theme-toggle',
-			'theme-toggle.script-abc123.js',
-		);
-		const weatherAppBunOutput = path.join(
-			outDir,
-			'src',
-			'components',
-			'weather-app',
-			'weather-app.script-def456.js',
-		);
-		const themeToggleExpectedOutput = path.join(
-			outDir,
-			'components',
-			'theme-toggle',
-			'theme-toggle.script-abc123.js',
-		);
-		const weatherAppExpectedOutput = path.join(outDir, 'components', 'weather-app', 'weather-app.script-def456.js');
-
-		(globalThis as typeof globalThis & { Bun?: unknown }).Bun = {
-			build: vi.fn(async () => {
-				fs.mkdirSync(path.dirname(themeToggleBunOutput), { recursive: true });
-				fs.mkdirSync(path.dirname(weatherAppBunOutput), { recursive: true });
-				fs.writeFileSync(themeToggleBunOutput, 'export const themeToggle = 1;', 'utf8');
-				fs.writeFileSync(weatherAppBunOutput, 'export const weatherApp = 2;', 'utf8');
-				return {
-					success: true,
-					logs: [],
-					outputs: [{ path: weatherAppBunOutput }, { path: themeToggleBunOutput }],
-				};
-			}),
-			hash: vi.fn(() => 1),
-			resolveSync: vi.fn((importPath: string) => importPath),
-		};
-
-		const freshAdapter = createBunBuildAdapter();
-		const result = await freshAdapter.build({
-			entrypoints: [themeToggleEntrypoint, weatherAppEntrypoint],
-			root,
-			outdir: outDir,
-			outbase: path.join(root, 'src'),
-			target: 'browser',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: true,
-			minify: false,
-			naming: '[dir]/[name]-[hash].[ext]',
-		});
-
-		assert.equal(result.success, true);
-		assert.deepEqual(result.outputs, [{ path: weatherAppExpectedOutput }, { path: themeToggleExpectedOutput }]);
-		assert.equal(fs.readFileSync(themeToggleExpectedOutput, 'utf8'), 'export const themeToggle = 1;');
-		assert.equal(fs.readFileSync(weatherAppExpectedOutput, 'utf8'), 'export const weatherApp = 2;');
-		assert.equal(fs.existsSync(themeToggleBunOutput), false);
-		assert.equal(fs.existsSync(weatherAppBunOutput), false);
-	} finally {
-		if (originalBun === undefined) {
-			delete (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-		} else {
-			(globalThis as typeof globalThis & { Bun?: unknown }).Bun = originalBun;
-		}
-		cleanupTempRoots();
-	}
-});
-
-test('BunBuildAdapter remaps Bun root-relative outputs back to outbase-relative paths', async () => {
-	const originalBun = (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-
-	try {
-		const root = createTempRoot('ecopages-bun-outbase-root-relative');
-		const srcDir = path.join(root, 'src', 'components', 'theme-toggle');
-		const outDir = path.join(root, 'dist', 'assets');
-		fs.mkdirSync(srcDir, { recursive: true });
-		fs.mkdirSync(outDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'theme-toggle.script.ts');
-		fs.writeFileSync(entryPath, 'export const themeToggle = 1;');
-
-		const bunRootRelativeOutputPath = path.join(outDir, 'src', 'components', 'theme-toggle', 'theme-toggle.script');
-		const expectedOutputPath = path.join(outDir, 'components', 'theme-toggle', 'theme-toggle.script');
-
-		(globalThis as typeof globalThis & { Bun?: unknown }).Bun = {
-			build: vi.fn(async () => {
-				fs.mkdirSync(path.dirname(bunRootRelativeOutputPath), { recursive: true });
-				fs.writeFileSync(bunRootRelativeOutputPath, 'export const themeToggle = 1;', 'utf8');
-				return {
-					success: true,
-					logs: [],
-					outputs: [{ path: bunRootRelativeOutputPath }],
-				};
-			}),
-			hash: vi.fn(() => 1),
-			resolveSync: vi.fn((importPath: string) => importPath),
-		};
-
-		const freshAdapter = createBunBuildAdapter();
-		const result = await freshAdapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			outbase: path.join(root, 'src'),
-			target: 'browser',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: true,
-			minify: false,
-			naming: '[dir]/[name]',
-		});
-
-		assert.equal(result.success, true);
-		assert.deepEqual(result.outputs, [{ path: `${expectedOutputPath}.js` }]);
-		assert.equal(fs.existsSync(`${expectedOutputPath}.js`), true);
-		assert.equal(fs.existsSync(bunRootRelativeOutputPath), false);
-		assert.equal(fs.readFileSync(`${expectedOutputPath}.js`, 'utf8'), 'export const themeToggle = 1;');
-	} finally {
-		if (originalBun === undefined) {
-			delete (globalThis as typeof globalThis & { Bun?: unknown }).Bun;
-		} else {
-			(globalThis as typeof globalThis & { Bun?: unknown }).Bun = originalBun;
-		}
-		cleanupTempRoots();
-	}
-});
-
-test('getAppBuildExecutor falls back to the app-owned adapter before the shared default adapter', async () => {
-	const appConfig = {
-		runtime: {},
-		loaders: new Map(),
-	} as any;
-	const appAdapter = new EsbuildBuildAdapter();
-
-	setAppBuildAdapter(appConfig, appAdapter);
-
-	assert.equal(getAppBuildAdapter(appConfig), appAdapter);
-	assert.equal(getAppBuildExecutor(appConfig), appAdapter);
-	assert.equal(getAppBuildOwnership(appConfig), 'bun-native');
-	assert.notEqual(getAppBuildAdapter(appConfig), defaultBuildAdapter);
-});
-
-test('getAppBuildAdapter falls back to the explicit Vite-host adapter when ownership is host-owned', () => {
-	const appConfig = {
-		runtime: {},
-		loaders: new Map(),
-	} as any;
-
-	setAppBuildOwnership(appConfig, 'vite-host');
-
-	assert.equal(getAppBuildOwnership(appConfig), 'vite-host');
-	assert.ok(getAppBuildAdapter(appConfig) instanceof ViteHostBuildAdapter);
-});
-
-test('createAppBuildExecutor injects app-owned plugins into builds', async () => {
-	const plugin = {
-		name: 'app-owned-plugin',
-		setup() {},
-	};
-	const adapter = {
-		build: vi.fn(async (options) => ({
-			success: true,
-			logs: [],
-			outputs: [{ path: options.outdir ? `${options.outdir}/entry.js` : '/tmp/entry.js' }],
-		})),
-		resolve: vi.fn(),
-		registerPlugin: vi.fn(),
-		getTranspileOptions: vi.fn(),
-	};
-	const appConfig = {
-		loaders: new Map(),
-		runtime: {},
-	} as any;
-
-	setAppBuildManifest(
-		appConfig,
-		createAppBuildManifest({
-			runtimePlugins: [plugin],
-		}),
-	);
-	const executor = createAppBuildExecutor({
-		development: false,
-		adapter,
-		getPlugins: () => getAppServerBuildPlugins(appConfig),
-	});
-
-	await executor.build({
-		entrypoints: ['/tmp/entry.ts'],
-		root: '/tmp',
-		outdir: '/tmp/out',
-		target: 'node',
-		format: 'esm',
-		sourcemap: 'none',
-		splitting: false,
-		minify: false,
-	});
-
-	assert.equal(adapter.build.mock.calls.length, 1);
-	assert.deepEqual(adapter.build.mock.calls[0][0].plugins, [plugin]);
-	assert.equal(adapter.registerPlugin.mock.calls.length, 0);
-});
-
-test('build manifest separates server and browser plugin sets', () => {
-	const loaderPlugin = { name: 'loader-plugin', setup() {} };
-	const runtimePlugin = { name: 'runtime-plugin', setup() {} };
-	const browserPlugin = { name: 'browser-plugin', setup() {} };
-	const appConfig = {
-		loaders: new Map(),
-		runtime: {},
-	} as any;
-
-	setAppBuildManifest(
-		appConfig,
-		createAppBuildManifest({
-			loaderPlugins: [loaderPlugin],
-			runtimePlugins: [runtimePlugin],
-			browserBundlePlugins: [browserPlugin],
-		}),
-	);
-
-	assert.deepEqual(getAppBuildManifest(appConfig).loaderPlugins, [loaderPlugin]);
-	assert.deepEqual(getAppServerBuildPlugins(appConfig), [loaderPlugin, runtimePlugin]);
-	assert.deepEqual(getAppBrowserBuildPlugins(appConfig), [loaderPlugin, runtimePlugin, browserPlugin]);
-});
-
-test('createConfiguredAppBuildManifest defaults loader plugins from app config', () => {
-	const loaderPlugin = { name: 'loader-plugin', setup() {} };
-	const runtimePlugin = { name: 'runtime-plugin', setup() {} };
-	const appConfig = {
-		loaders: new Map([[loaderPlugin.name, loaderPlugin]]),
-		runtime: {},
-	} as any;
-
-	const manifest = createConfiguredAppBuildManifest(appConfig, {
-		runtimePlugins: [runtimePlugin],
-	});
-
-	assert.deepEqual(manifest.loaderPlugins, [loaderPlugin]);
-	assert.deepEqual(manifest.runtimePlugins, [runtimePlugin]);
-	assert.deepEqual(manifest.browserBundlePlugins, []);
-});
-
-test('updateAppBuildManifest rebuilds the app manifest from config-owned loaders and explicit runtime plugins', () => {
-	const loaderPlugin = { name: 'loader-plugin', setup() {} };
-	const runtimePlugin = { name: 'runtime-plugin', setup() {} };
-	const browserPlugin = { name: 'browser-plugin', setup() {} };
-	const appConfig = {
-		loaders: new Map([[loaderPlugin.name, loaderPlugin]]),
-		runtime: {},
-	} as any;
-
-	updateAppBuildManifest(appConfig, {
-		runtimePlugins: [runtimePlugin],
-		browserBundlePlugins: [browserPlugin],
-	});
-
-	assert.deepEqual(getAppBuildManifest(appConfig).loaderPlugins, [loaderPlugin]);
-	assert.deepEqual(getAppServerBuildPlugins(appConfig), [loaderPlugin, runtimePlugin]);
-	assert.deepEqual(getAppBrowserBuildPlugins(appConfig), [loaderPlugin, runtimePlugin, browserPlugin]);
-});
-
-test('collectConfiguredAppBuildManifestContributions gathers processor and integration contributions during config build', async () => {
-	const contributionOrder: string[] = [];
-	const processorRuntimePlugin = { name: 'processor-runtime-plugin', setup() {} };
-	const processorBrowserPlugin = { name: 'processor-browser-plugin', setup() {} };
-	const integrationRuntimePlugin = { name: 'integration-runtime-plugin', setup() {} };
-	const processor = {
-		plugins: [processorRuntimePlugin],
-		buildPlugins: [processorBrowserPlugin],
-		prepareBuildContributions: vi.fn(async () => {
-			contributionOrder.push('processor-prepare');
-		}),
-	};
-	const integration = {
-		plugins: [integrationRuntimePlugin],
-		setConfig: vi.fn(() => contributionOrder.push('integration-config')),
-		prepareBuildContributions: vi.fn(async () => {
-			contributionOrder.push('integration-prepare');
-		}),
-	};
-
-	const contributions = await collectConfiguredAppBuildManifestContributions({
-		processors: new Map([['processor', processor]]),
-		integrations: [integration],
-	} as any);
-
-	assert.deepEqual(contributionOrder, ['processor-prepare', 'integration-config', 'integration-prepare']);
-	assert.deepEqual(contributions.runtimePlugins, [processorRuntimePlugin, integrationRuntimePlugin]);
-	assert.deepEqual(contributions.browserBundlePlugins, [processorBrowserPlugin]);
-});
-
-test('setupAppRuntimePlugins runs runtime setup without recomposing manifest contributions', async () => {
-	const contributionOrder: string[] = [];
-	const processorRuntimePlugin = { name: 'processor-runtime-plugin', setup() {} };
-	const integrationRuntimePlugin = { name: 'integration-runtime-plugin', setup() {} };
-	const processor = {
-		plugins: [processorRuntimePlugin],
-		setup: vi.fn(async () => {
-			contributionOrder.push('processor-setup');
-		}),
-	};
-	const integration = {
-		plugins: [integrationRuntimePlugin],
-		setConfig: vi.fn(() => contributionOrder.push('integration-config')),
-		setRuntimeOrigin: vi.fn(() => contributionOrder.push('integration-origin')),
-		setHmrManager: vi.fn(() => contributionOrder.push('integration-hmr')),
-		setup: vi.fn(async () => {
-			contributionOrder.push('integration-setup');
-		}),
-	};
-	const observedRuntimePlugins: string[] = [];
-
-	await setupAppRuntimePlugins({
-		appConfig: {
-			processors: new Map([['processor', processor]]),
-			integrations: [integration],
-		} as any,
-		runtimeOrigin: 'http://localhost:3000',
-		hmrManager: {} as any,
-		onRuntimePlugin: (plugin) => observedRuntimePlugins.push(plugin.name),
-	});
-
-	assert.deepEqual(contributionOrder, [
-		'processor-setup',
-		'integration-config',
-		'integration-origin',
-		'integration-hmr',
-		'integration-setup',
-	]);
-	assert.deepEqual(observedRuntimePlugins, ['processor-runtime-plugin', 'integration-runtime-plugin']);
-});
-
-test('EsbuildBuildAdapter supports module virtual modules', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-virtual-module');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'entry.ts');
-		fs.writeFileSync(entryPath, "import answer from 'virtual:answer';\nexport const value = answer;");
-
-		const adapter = new EsbuildBuildAdapter();
-
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-			plugins: [
-				{
-					name: 'virtual-module-test',
-					setup(build: EcoBuildPluginBuilder) {
-						build.module('virtual:answer', () => ({
-							loader: 'object',
-							exports: {
-								default: 42,
-							},
-						}));
-					},
-				},
-			],
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-
-		const outputSource = fs.readFileSync(outputPath, 'utf-8');
-		assert.match(outputSource, /42/);
-	} finally {
-		cleanupTempRoots();
-	}
-});
-
-test('EsbuildBuildAdapter applies build plugin CSS transforms to imported CSS strings', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-css');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const cssPath = path.join(srcDir, 'styles.css');
-		const entryPath = path.join(srcDir, 'entry.ts');
-
-		fs.writeFileSync(cssPath, '.counter { color: red; }');
-		fs.writeFileSync(entryPath, "import styles from './styles.css';\nexport const cssText = styles;");
-
-		const adapter = new EsbuildBuildAdapter();
-
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-			plugins: [
-				{
-					name: 'css-bridge-replacement-test',
-					setup(build) {
-						build.onLoad({ filter: /\.css$/ }, async (args) => {
-							const contents = fs.readFileSync(args.path, 'utf-8');
-							return {
-								loader: 'object',
-								exports: {
-									default: `/* transformed */\n${contents}`,
-								},
-							};
-						});
-					},
-				},
-			],
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-
-		const outputSource = fs.readFileSync(outputPath, 'utf-8');
-		assert.match(outputSource, /\/\* transformed \*\//);
-		assert.match(outputSource, /\.counter \{ color: red; \}/);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter resolves tsconfig path aliases', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-tsconfig-paths');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		const libDir = path.join(srcDir, 'lib');
-		fs.mkdirSync(libDir, { recursive: true });
-
-		const tsconfigPath = path.join(root, 'tsconfig.json');
-		fs.writeFileSync(
-			tsconfigPath,
-			JSON.stringify({
-				compilerOptions: {
-					baseUrl: '.',
-					paths: {
-						'@/*': ['src/*'],
-					},
-				},
-			}),
-		);
-
-		const utilPath = path.join(libDir, 'count.ts');
-		fs.writeFileSync(utilPath, 'export const count = 7;');
-
-		const entryPath = path.join(srcDir, 'entry.ts');
-		fs.writeFileSync(entryPath, "import { count } from '@/lib/count';\nexport const value = count;");
-
-		const adapter = new EsbuildBuildAdapter();
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-
-		const outputSource = fs.readFileSync(outputPath, 'utf-8');
-		assert.match(outputSource, /7/);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter compiles decorated classes without legacy mode', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-decorated-declare');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'entry.ts');
-		fs.writeFileSync(
-			entryPath,
-			[
-				'function sealed<T extends new (...args: never[]) => object>(value: T) {',
-				'\treturn value;',
-				'}',
-				'@sealed',
-				'class Counter {}',
-				'export const ready = typeof Counter === "function";',
-			].join('\n'),
-		);
-
-		const adapter = new EsbuildBuildAdapter();
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter compiles decorated accessor fields', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-decorated-accessor');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'entry.ts');
-		fs.writeFileSync(
-			entryPath,
-			[
-				'function property(_options: unknown) {',
-				'\treturn function (_target: unknown, _context: unknown) {};',
-				'}',
-				'class Counter {',
-				'\t@property({ type: Number }) accessor count = 0;',
-				'}',
-				'export const ready = typeof Counter === "function";',
-			].join('\n'),
-		);
-
-		const adapter = new EsbuildBuildAdapter();
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter downlevels accessor fields for browser target bundles', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-browser-accessor');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'entry.ts');
-		fs.writeFileSync(
-			entryPath,
-			[
-				'class Counter {',
-				'\taccessor count = 0;',
-				'}',
-				'export const ready = typeof Counter === "function";',
-			].join('\n'),
-		);
-
-		const adapter = new EsbuildBuildAdapter();
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'browser',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-
-		const outputSource = fs.readFileSync(outputPath, 'utf-8');
-		assert.doesNotMatch(outputSource, /accessor\s+count/);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter applies plugin CSS transforms for CSS imported in TS modules', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-plugin-css-transform');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const cssPath = path.join(srcDir, 'styles.css');
-		const entryPath = path.join(srcDir, 'entry.ts');
-
-		fs.writeFileSync(cssPath, '.counter { color: red; }');
-		fs.writeFileSync(entryPath, "import styles from './styles.css';\nexport const cssText = styles;");
-
-		const adapter = new EsbuildBuildAdapter();
-
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-			plugins: [
-				{
-					name: 'css-transform-test-plugin',
-					setup(build) {
-						build.onLoad({ filter: /\.css$/ }, async (args) => {
-							const contents = fs.readFileSync(args.path, 'utf-8');
-							return {
-								loader: 'object',
-								exports: {
-									default: `/* postprocessed */\n${contents}`,
-								},
-							};
-						});
-					},
-				},
-			],
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-
-		const outputSource = fs.readFileSync(outputPath, 'utf-8');
-		assert.match(outputSource, /\/\* postprocessed \*\//);
-		assert.match(outputSource, /\.counter \{ color: red; \}/);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter supports synchronous onLoad transforms for entrypoints', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-entrypoint-onload');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'entry.tsx');
-		fs.writeFileSync(
-			entryPath,
-			[
-				"import { jsx as _jsx } from 'react/jsx-runtime';",
-				"export const view = () => _jsx('button', { children: 'ok' });",
-			].join('\n'),
-		);
-
-		const adapter = new EsbuildBuildAdapter();
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'browser',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-			plugins: [
-				{
-					name: 'entrypoint-onload-test-plugin',
-					setup(build) {
-						build.onLoad({ filter: /entry\.tsx$/ }, (args) => ({
-							contents: fs.readFileSync(args.path, 'utf-8'),
-							loader: 'tsx',
-							resolveDir: path.dirname(args.path),
-						}));
-					},
-				},
-			],
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-
-		const outputSource = fs.readFileSync(outputPath, 'utf-8');
-		assert.match(outputSource, /button/);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter returns dependency graph entrypoint mapping', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-dependency-graph');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const sharedPath = path.join(srcDir, 'shared.ts');
-		const leafPath = path.join(srcDir, 'leaf.ts');
-		const entryPath = path.join(srcDir, 'entry.ts');
-
-		fs.writeFileSync(sharedPath, "import { leaf } from './leaf';\nexport const shared = leaf + 1;");
-		fs.writeFileSync(leafPath, 'export const leaf = 2;');
-		fs.writeFileSync(entryPath, "import { shared } from './shared';\nexport const value = shared;");
-
-		const adapter = new EsbuildBuildAdapter();
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-		});
-
-		assert.equal(result.success, true);
-		assert.ok(result.dependencyGraph);
-
-		const dependencies = result.dependencyGraph?.entrypoints[path.resolve(entryPath)] ?? [];
-
-		assert.ok(dependencies.includes(path.resolve(entryPath)));
-		assert.ok(dependencies.includes(path.resolve(sharedPath)));
-		assert.ok(dependencies.includes(path.resolve(leafPath)));
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter honors first-match plugin precedence within one build', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-plugin-precedence');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const cssPath = path.join(srcDir, 'styles.css');
-		const entryPath = path.join(srcDir, 'entry.ts');
-
-		fs.writeFileSync(cssPath, '.counter { color: red; }');
-		fs.writeFileSync(entryPath, "import styles from './styles.css';\nexport const cssText = styles;");
-
-		const adapter = new EsbuildBuildAdapter();
-
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-			plugins: [
-				{
-					name: 'first-css-plugin',
-					setup(build) {
-						build.onLoad({ filter: /\.css$/ }, async () => {
-							return {
-								loader: 'object',
-								exports: {
-									default: 'first-css',
-								},
-							};
-						});
-					},
-				},
-				{
-					name: 'second-css-plugin',
-					setup(build) {
-						build.onLoad({ filter: /\.css$/ }, async () => {
-							return {
-								loader: 'object',
-								exports: {
-									default: 'second-css',
-								},
-							};
-						});
-					},
-				},
-			],
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-
-		const outputSource = fs.readFileSync(outputPath, 'utf-8');
-		assert.match(outputSource, /first-css/);
-		assert.doesNotMatch(outputSource, /second-css/);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter resolves templated naming patterns to concrete output files', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-naming-template');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'entry.ts');
-		fs.writeFileSync(entryPath, 'export const value = 1;');
-
-		const adapter = new EsbuildBuildAdapter();
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'node',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: true,
-			minify: false,
-			naming: '[name].[ext]',
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-		assert.equal(fs.existsSync(path.join(outDir, '[name].[ext]')), false);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});
-
-test('EsbuildBuildAdapter forwards define replacements into bundled runtime modules', async () => {
-	try {
-		const root = createTempRoot('ecopages-esbuild-define-runtime');
-		const srcDir = path.join(root, 'src');
-		const outDir = path.join(root, 'dist');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entryPath = path.join(srcDir, 'entry.js');
-		fs.writeFileSync(entryPath, 'export const mode = process.env.NODE_ENV;\n');
-
-		const adapter = new EsbuildBuildAdapter();
-		const result = await adapter.build({
-			entrypoints: [entryPath],
-			root,
-			outdir: outDir,
-			target: 'browser',
-			format: 'esm',
-			sourcemap: 'none',
-			splitting: false,
-			minify: false,
-			define: {
-				'process.env.NODE_ENV': '"development"',
-			},
-		});
-
-		assert.equal(result.success, true);
-
-		const outputPath = result.outputs.find((output) => output.path.endsWith('entry.js'))?.path;
-		assert.ok(outputPath);
-
-		const outputSource = fs.readFileSync(outputPath, 'utf-8');
-		assert.match(outputSource, /development/);
-		assert.doesNotMatch(outputSource, /production/);
-	} finally {
-		cleanupTempRoots();
-		clearNodeCssBridge();
-	}
-});