@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/adapters/bun/server-adapter.ts

@@ -9,9 +9,15 @@ import { fileSystem } from '@ecopages/file-system';
 import { SharedServerAdapter } from '../shared/server-adapter.ts';
 import type { ServerAdapterResult } from '../abstract/server-adapter.ts';
 import { ApiResponseBuilder } from '../shared/api-response.ts';
+import { installSharedRuntimeBuildExecutor } from '../shared/runtime-bootstrap.ts';
 
 import { ServerRouteHandler, type ServerRouteHandlerParams } from '../shared/server-route-handler.ts';
 import { ServerStaticBuilder, type ServerStaticBuilderParams } from '../shared/server-static-builder';
+import {
+	injectHmrRuntimeIntoHtmlResponse,
+	isHtmlResponse,
+	shouldInjectHmrHtmlResponse,
+} from '../shared/hmr-html-response';
 import { ClientBridge } from './client-bridge';
 import { HmrManager } from './hmr-manager';
 import { ServerLifecycle } from './server-lifecycle.ts';
@@ -108,15 +114,14 @@ export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams
 	 * Only injects in watch mode when HMR manager is enabled.
 	 */
 	private shouldInjectHmrScript(): boolean {
-		return this.options?.watch === true && this.hmrManager?.isEnabled() === true;
+		return shouldInjectHmrHtmlResponse(this.options?.watch === true, this.hmrManager);
 	}
 
 	/**
 	 * Checks if a response contains HTML content.
 	 */
 	private isHtmlResponse(response: Response): boolean {
-		const contentType = response.headers.get('Content-Type');
-		return contentType !== null && contentType.startsWith('text/html');
+		return isHtmlResponse(response);
 	}
 
 	/**
@@ -125,18 +130,7 @@ export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams
 	 */
 	private async maybeInjectHmrScript(response: Response): Promise<Response> {
 		if (this.shouldInjectHmrScript() && this.isHtmlResponse(response)) {
-			const html = await response.text();
-			const hmrScript = `<script type="module">import '/_hmr_runtime.js';</script>`;
-			const updatedHtml = html.replace(/<\/html>/i, `${hmrScript}</html>`);
-
-			const headers = new Headers(response.headers);
-			headers.delete('Content-Length');
-
-			return new Response(updatedHtml, {
-				status: response.status,
-				statusText: response.statusText,
-				headers,
-			});
+			return injectHmrRuntimeIntoHtmlResponse(response);
 		}
 		return response;
 	}
@@ -146,6 +140,10 @@ export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams
 	 * Delegates to ServerLifecycle for setup.
 	 */
 	public async initialize(): Promise<void> {
+		installSharedRuntimeBuildExecutor(this.appConfig, {
+			development: this.options?.watch === true,
+		});
+
 		this.bridge = this.bridgeFactory ?? new ClientBridge();
 		this.hmrManager = this.hmrManagerFactory ?? new HmrManager({ appConfig: this.appConfig, bridge: this.bridge });
 		this.lifecycle =
@@ -163,6 +161,7 @@ export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams
 			appConfig: this.appConfig,
 			staticSiteGenerator: this.staticSiteGenerator,
 			serveOptions: this.serveOptions,
+			apiHandlers: this.apiHandlers,
 		};
 
 		this.staticBuilder = this.staticBuilderFactory
@@ -176,22 +175,24 @@ export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams
 	 * Refreshes the router routes during watch mode.
 	 */
 	private async refreshRouterRoutes(): Promise<void> {
-		if (this.serverInstance && typeof this.serverInstance.reload === 'function') {
-			try {
-				await this.initSharedRouter();
-				this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
-				const options = this.getServerOptions({ enableHmr: true });
-				this.serverInstance.reload(options as BunNativeServeOptions);
-				appLogger.debug('Server routes updated with dynamic routes');
-			} catch (error) {
-				if (error instanceof Error) {
-					this.hmrManager.broadcast({ type: 'error', message: error.message });
-					appLogger.error('Failed to refresh router routes:', error);
-				}
-			}
-		} else {
+		if (!this.serverInstance || typeof this.serverInstance.reload !== 'function') {
 			appLogger.error('Server instance is not available for reloading');
+			return;
 		}
+
+		await this.createSharedWatchRefreshCallback({
+			staticRoutes: this.staticRoutes,
+			hmrManager: this.hmrManager,
+			onRoutesReady: () => {
+				const options = this.getServerOptions({ enableHmr: true });
+				this.serverInstance!.reload(options as BunNativeServeOptions);
+				appLogger.debug('Server routes updated with dynamic routes');
+			},
+			onError: (error) => {
+				this.hmrManager.broadcast({ type: 'error', message: error.message });
+				appLogger.error('Failed to refresh router routes:', error);
+			},
+		})();
 	}
 
 	private async watch(): Promise<void> {
@@ -344,8 +345,10 @@ export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams
 	 */
 	public async buildStatic(options?: { preview?: boolean }): Promise<void> {
 		if (!this.fullyInitialized) {
-			await this.initSharedRouter();
-			this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
+			await this.initializeSharedRouteHandling({
+				staticRoutes: this.staticRoutes,
+				hmrManager: this.hmrManager,
+			});
 		}
 
 		await this.staticBuilder.build(options, {
@@ -382,8 +385,10 @@ export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams
 		this.serverInstance = server;
 		appLogger.debug('Completing server initialization with dynamic routes');
 
-		await this.initSharedRouter();
-		this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
+		await this.initializeSharedRouteHandling({
+			staticRoutes: this.staticRoutes,
+			hmrManager: this.hmrManager,
+		});
 
 		this.fullyInitialized = true;
 
@@ -422,7 +427,9 @@ export class BunServerAdapter extends SharedServerAdapter<BunServerAdapterParams
 			hmrManager: this.hmrManager,
 		});
 
-		// Check if we need to manually inject HMR script since we're bypassing route level HMR wrapping
+		// Filesystem page responses are wrapped by ServerRouteHandler. This adapter-
+		// level pass only covers HTML returned by explicit API handlers, which bypass
+		// that route-layer wrapper and would otherwise miss the dev HMR runtime.
 		return await this.maybeInjectHmrScript(response);
 	}
 

package/src/adapters/bun/server-lifecycle.ts

@@ -1,15 +1,16 @@
-import path from 'node:path';
 import { getBunRuntime } from '../../utils/runtime.ts';
-import { RESOLVED_ASSETS_DIR } from '../../constants';
-import { defaultBuildAdapter } from '../../build/build-adapter.ts';
 import { appLogger } from '../../global/app-logger';
 import type { EcoPagesAppConfig } from '../../internal-types';
 import type { EcoBuildPlugin } from '../../build/build-types.ts';
-import { fileSystem } from '@ecopages/file-system';
 import { StaticSiteGenerator } from '../../static-site-generator/static-site-generator';
-import { ProjectWatcher } from '../../watchers/project-watcher';
 import type { ClientBridge } from './client-bridge';
 import type { HmrManager } from './hmr-manager';
+import {
+	bindSharedRuntimeHmrManager,
+	initializeSharedRuntimePlugins,
+	prepareSharedRuntimePublicDir,
+	startSharedProjectWatching,
+} from '../shared/runtime-bootstrap.ts';
 
 export interface WatcherCallbacks {
 	refreshRouterRoutesCallback: () => Promise<void>;
@@ -23,7 +24,13 @@ export interface ServerLifecycleParams {
 }
 
 /**
- * Handles server lifecycle: initialization, plugins, loaders, and file watching.
+ * Coordinates Bun-runtime server startup side effects for one app instance.
+ *
+ * @remarks
+ * This class keeps runtime-only concerns together: build-runtime bootstrapping,
+ * Bun loader registration, public asset preparation, plugin setup, and file
+ * watching. Core config/build state is expected to already be finalized before
+ * this lifecycle runs.
  */
 export class ServerLifecycle {
 	private readonly appConfig: EcoPagesAppConfig;
@@ -40,94 +47,55 @@ export class ServerLifecycle {
 	}
 
 	/**
-	 * Initializes the server's core components.
-	 * @returns The static site generator instance for use by other components
+	 * Initializes the runtime services that Bun startup depends on.
+	 *
+	 * @returns The static-site generator instance reused by the adapter.
 	 */
 	async initialize(): Promise<StaticSiteGenerator> {
 		this.staticSiteGenerator = new StaticSiteGenerator({ appConfig: this.appConfig });
 		await this.hmrManager.buildRuntime();
 
 		this.setupLoaders();
-		this.copyPublicDir();
+		prepareSharedRuntimePublicDir(this.appConfig);
 
 		return this.staticSiteGenerator;
 	}
 
 	/**
-	 * Sets up Bun loaders from config.
-	 * Note: This will be abstracted to a LoaderStrategy interface in #4 Runtime Abstraction.
+	 * Registers config-owned build loaders with Bun's runtime plugin API.
+	 *
+	 * @remarks
+	 * Bun remains responsible only for transport-level plugin registration here.
+	 * Loader ownership and composition were already finalized during config build.
 	 */
 	setupLoaders(): void {
 		const loaders = this.appConfig.loaders;
 		for (const loader of loaders.values()) {
-			defaultBuildAdapter.registerPlugin(loader);
 			getBunRuntime()?.plugin(loader as any);
 		}
 	}
 
 	/**
-	 * Copies public directory contents to dist root.
-	 * Static files are served from root (e.g., /favicon.ico, /robots.txt).
-	 */
-	copyPublicDir(): void {
-		try {
-			const srcPublicDir = path.join(this.appConfig.rootDir, this.appConfig.srcDir, this.appConfig.publicDir);
-
-			if (fileSystem.exists(srcPublicDir)) {
-				fileSystem.copyDir(srcPublicDir, path.join(this.appConfig.rootDir, this.appConfig.distDir));
-			}
-
-			fileSystem.ensureDir(path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR));
-		} catch (error) {
-			appLogger.error(
-				`Failed to copy public directory: ${error instanceof Error ? error.message : String(error)}`,
-			);
-			throw error;
-		}
-	}
-
-	/**
-	 * Initializes processors and integrations.
-	 * @param options.watch - Whether watch mode is enabled
+	 * Runs runtime-only processor and integration setup for this Bun app session.
+	 *
+	 * @param options.watch Whether watch mode is enabled.
+	 * @returns The browser build plugins visible to HMR after runtime setup.
 	 */
 	async initializePlugins(options?: { watch?: boolean }): Promise<EcoBuildPlugin[]> {
 		try {
 			const hmrEnabled = !!options?.watch;
 			this.hmrManager.setEnabled(hmrEnabled);
 
-			const processorBuildPlugins: EcoBuildPlugin[] = [];
-
-			const processorPromises = Array.from(this.appConfig.processors.values()).map(async (processor) => {
-				await processor.setup();
-				if (processor.plugins) {
-					for (const plugin of processor.plugins) {
-						defaultBuildAdapter.registerPlugin(plugin);
-						getBunRuntime()?.plugin(plugin as any);
-					}
-				}
-				if (processor.buildPlugins) {
-					processorBuildPlugins.push(...processor.buildPlugins);
-				}
-			});
-
-			const integrationPromises = this.appConfig.integrations.map(async (integration) => {
-				integration.setConfig(this.appConfig);
-				integration.setRuntimeOrigin(this.runtimeOrigin);
-				integration.setHmrManager(this.hmrManager);
-				await integration.setup();
-
-				for (const plugin of integration.plugins) {
-					defaultBuildAdapter.registerPlugin(plugin);
+			await initializeSharedRuntimePlugins({
+				appConfig: this.appConfig,
+				runtimeOrigin: this.runtimeOrigin,
+				hmrManager: this.hmrManager,
+				onRuntimePlugin: (plugin) => {
 					getBunRuntime()?.plugin(plugin as any);
-				}
+				},
 			});
 
-			await Promise.all([...processorPromises, ...integrationPromises]);
-
-			const loaderPlugins = Array.from(this.appConfig.loaders.values());
-			const allBuildPlugins = [...loaderPlugins, ...processorBuildPlugins];
-			this.hmrManager.setPlugins(allBuildPlugins);
-			return allBuildPlugins;
+			return bindSharedRuntimeHmrManager(this.appConfig, this.hmrManager);
 		} catch (error) {
 			appLogger.error(`Failed to initialize plugins: ${error instanceof Error ? error.message : String(error)}`);
 			throw error;
@@ -135,19 +103,21 @@ export class ServerLifecycle {
 	}
 
 	/**
-	 * Starts file watching for HMR.
+	 * Starts file watching and wires change events back into the adapter refresh
+	 * callback.
 	 */
 	async startWatching(callbacks: WatcherCallbacks): Promise<void> {
-		const watcherInstance = new ProjectWatcher({
-			config: this.appConfig,
+		await startSharedProjectWatching({
+			appConfig: this.appConfig,
 			refreshRouterRoutesCallback: callbacks.refreshRouterRoutesCallback,
 			hmrManager: this.hmrManager,
 			bridge: this.bridge,
 		});
-
-		await watcherInstance.createWatcherSubscription();
 	}
 
+	/**
+	 * Returns the static-site generator created during initialization.
+	 */
 	getStaticSiteGenerator(): StaticSiteGenerator {
 		return this.staticSiteGenerator;
 	}

package/src/adapters/index.ts

@@ -1,5 +1,5 @@
 export { EcopagesApp, createApp } from './bun/create-app.ts';
-export { defineApiHandler, defineGroupHandler } from './bun/define-api-handler.ts';
+export { defineApiHandler, defineGroupHandler, type GroupHandler } from './shared/define-api-handler.ts';
 export { NodeServerAdapter, createNodeServerAdapter } from './node/server-adapter.ts';
 export { EcopagesApp as NodeAdapterEcopagesApp, createNodeApp } from './node/create-app.ts';
 export type { NodeServerAdapterParams, NodeServerAdapterResult } from './node/server-adapter.ts';

package/src/adapters/node/bootstrap-dependency-resolver.test.ts

@@ -0,0 +1,282 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { test } from 'vitest';
+import {
+	createNodeBootstrapPlugin,
+	getNodeUnsupportedBuiltinError,
+	resolveNodeBootstrapDependency,
+} from './bootstrap-dependency-resolver.ts';
+
+function writePackage(packageDir: string, options: { name: string; main?: string }) {
+	fs.mkdirSync(packageDir, { recursive: true });
+	fs.writeFileSync(
+		path.join(packageDir, 'package.json'),
+		JSON.stringify({
+			name: options.name,
+			main: options.main ?? 'index.js',
+		}),
+		'utf8',
+	);
+	const entryFilePath = path.join(packageDir, options.main ?? 'index.js');
+	fs.mkdirSync(path.dirname(entryFilePath), { recursive: true });
+	fs.writeFileSync(entryFilePath, 'export default null;\n', 'utf8');
+}
+
+test('resolveNodeBootstrapDependency keeps relative, node, and workspace specifiers in the bundle graph', () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-bootstrap-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+
+	try {
+		const options = {
+			projectDir: rootDir,
+			runtimeNodeModulesDir: path.join(rootDir, '.eco', 'node_modules'),
+		};
+
+		assert.equal(resolveNodeBootstrapDependency({ path: './local.ts' }, options), undefined);
+		assert.equal(resolveNodeBootstrapDependency({ path: 'node:path' }, options), undefined);
+		assert.equal(resolveNodeBootstrapDependency({ path: '@/data/demo-data' }, options), undefined);
+		assert.deepEqual(resolveNodeBootstrapDependency({ path: '@ecopages/core' }, options), {
+			path: require.resolve('@ecopages/core'),
+		});
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});
+
+test('resolveNodeBootstrapDependency externalizes third-party packages and links them into runtime node_modules', () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-bootstrap-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	const importerPath = path.join(rootDir, 'packages', 'example', 'src', 'index.ts');
+	fs.mkdirSync(path.dirname(importerPath), { recursive: true });
+	fs.writeFileSync(importerPath, 'export default null;\n', 'utf8');
+	writePackage(path.join(rootDir, 'node_modules', 'fast-glob'), { name: 'fast-glob', main: 'out/index.js' });
+
+	try {
+		const runtimeNodeModulesDir = path.join(rootDir, '.eco', 'node_modules');
+		const result = resolveNodeBootstrapDependency(
+			{ path: 'fast-glob', importer: importerPath },
+			{ projectDir: rootDir, runtimeNodeModulesDir },
+		);
+
+		assert.deepEqual(result, { path: 'fast-glob', external: true });
+		assert.equal(
+			fs.realpathSync(path.join(runtimeNodeModulesDir, 'fast-glob')),
+			fs.realpathSync(path.join(rootDir, 'node_modules', 'fast-glob')),
+		);
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});
+
+test('resolveNodeBootstrapDependency resolves workspace-source third-party imports from the app project boundary', () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-bootstrap-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	const importerPath = path.join(rootDir, 'packages', 'react-plugin', 'src', 'plugin.ts');
+	fs.mkdirSync(path.dirname(importerPath), { recursive: true });
+	fs.writeFileSync(importerPath, 'export default null;\n', 'utf8');
+	writePackage(path.join(rootDir, 'node_modules', 'react'), { name: 'react', main: 'index.js' });
+
+	try {
+		const runtimeNodeModulesDir = path.join(rootDir, '.eco', 'node_modules');
+		const result = resolveNodeBootstrapDependency(
+			{ path: 'react', importer: importerPath },
+			{ projectDir: rootDir, runtimeNodeModulesDir },
+		);
+
+		assert.deepEqual(result, { path: 'react', external: true });
+		assert.equal(
+			fs.realpathSync(path.join(runtimeNodeModulesDir, 'react')),
+			fs.realpathSync(path.join(rootDir, 'node_modules', 'react')),
+		);
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});
+
+test('resolveNodeBootstrapDependency resolves nested third-party dependencies from the importer package context', () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-bootstrap-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	const importerPackageDir = path.join(rootDir, 'node_modules', 'dep-a');
+	writePackage(importerPackageDir, { name: 'dep-a' });
+	const nestedDependencyDir = path.join(importerPackageDir, 'node_modules', 'dep-b');
+	writePackage(nestedDependencyDir, { name: 'dep-b' });
+	const importerPath = path.join(importerPackageDir, 'index.js');
+
+	try {
+		const runtimeNodeModulesDir = path.join(rootDir, '.eco', 'node_modules');
+		const result = resolveNodeBootstrapDependency(
+			{ path: 'dep-b', importer: importerPath },
+			{ projectDir: rootDir, runtimeNodeModulesDir },
+		);
+
+		assert.deepEqual(result, { path: 'dep-b', external: true });
+		assert.equal(fs.realpathSync(path.join(runtimeNodeModulesDir, 'dep-b')), fs.realpathSync(nestedDependencyDir));
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});
+
+test('createNodeBootstrapPlugin wires the shared resolution policy into an Eco build plugin', async () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-bootstrap-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	writePackage(path.join(rootDir, 'node_modules', 'fast-glob'), { name: 'fast-glob', main: 'out/index.js' });
+
+	try {
+		const plugin = createNodeBootstrapPlugin({
+			projectDir: rootDir,
+			runtimeNodeModulesDir: path.join(rootDir, '.eco', 'node_modules'),
+		});
+
+		let onResolveCallback: ((args: { path: string; importer?: string; namespace?: string }) => unknown) | undefined;
+
+		await plugin.setup({
+			onResolve(_options, callback) {
+				onResolveCallback = callback;
+			},
+			onLoad() {},
+			module() {},
+		});
+
+		assert.ok(onResolveCallback);
+		assert.deepEqual(onResolveCallback?.({ path: 'fast-glob' }), {
+			path: 'fast-glob',
+			external: true,
+		});
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});
+
+test('createNodeBootstrapPlugin rewrites import.meta only for declared bootstrap files', async () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-bootstrap-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	const bootstrapFile = path.join(rootDir, 'eco.config.ts');
+	const regularFile = path.join(rootDir, 'src', 'page.kita.tsx');
+	fs.mkdirSync(path.dirname(regularFile), { recursive: true });
+	fs.writeFileSync(bootstrapFile, 'export default import.meta.dirname;\n', 'utf8');
+	fs.writeFileSync(regularFile, 'export default import.meta.dirname;\n', 'utf8');
+
+	try {
+		const plugin = createNodeBootstrapPlugin({
+			projectDir: rootDir,
+			runtimeNodeModulesDir: path.join(rootDir, '.eco', 'node_modules'),
+			preserveImportMetaPaths: [bootstrapFile],
+		});
+
+		let onLoadCallback: ((args: { path: string; namespace?: string }) => Promise<unknown> | unknown) | undefined;
+
+		await plugin.setup({
+			onResolve() {},
+			onLoad(_options, callback) {
+				onLoadCallback = callback;
+			},
+			module() {},
+		});
+
+		assert.ok(onLoadCallback);
+		const bootstrapResult = await onLoadCallback?.({ path: bootstrapFile });
+		const regularResult = await onLoadCallback?.({ path: regularFile });
+
+		assert.equal(typeof (bootstrapResult as { contents?: string } | undefined)?.contents, 'string');
+		assert.equal(
+			bootstrapResult && typeof bootstrapResult === 'object' && 'contents' in bootstrapResult
+				? String((bootstrapResult as { contents: string }).contents).includes(
+						JSON.stringify(path.dirname(bootstrapFile)),
+					)
+				: false,
+			true,
+		);
+		assert.equal(regularResult, undefined);
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});
+
+test('createNodeBootstrapPlugin injects side-effect imports for project re-export barrels', async () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-bootstrap-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	const barrelFile = path.join(rootDir, 'src', 'layouts', 'base-layout', 'index.ts');
+	fs.mkdirSync(path.dirname(barrelFile), { recursive: true });
+	fs.writeFileSync(
+		barrelFile,
+		[
+			"export * from './base-layout.kita';",
+			"export { BaseLayout } from './base-layout.kita';",
+			"export type { BaseLayoutProps } from './base-layout.kita';",
+		].join('\n'),
+		'utf8',
+	);
+
+	try {
+		const plugin = createNodeBootstrapPlugin({
+			projectDir: rootDir,
+			runtimeNodeModulesDir: path.join(rootDir, '.eco', 'node_modules'),
+		});
+
+		let onLoadCallback: ((args: { path: string; namespace?: string }) => Promise<unknown> | unknown) | undefined;
+
+		await plugin.setup({
+			onResolve() {},
+			onLoad(_options, callback) {
+				onLoadCallback = callback;
+			},
+			module() {},
+		});
+
+		assert.ok(onLoadCallback);
+		const result = await onLoadCallback?.({ path: barrelFile });
+		const contents =
+			result && typeof result === 'object' && 'contents' in result
+				? String((result as { contents: string }).contents)
+				: '';
+
+		assert.match(contents, /^import \* as __eco_bootstrap_reexport_0 from '\.\/base-layout\.kita';/m);
+		assert.match(contents, /^void __eco_bootstrap_reexport_0;$/m);
+		assert.match(contents, /export \* from '\.\/base-layout\.kita';/);
+		assert.match(contents, /export \{ BaseLayout \} from '\.\/base-layout\.kita';/);
+		assert.match(contents, /export type \{ BaseLayoutProps \} from '\.\/base-layout\.kita';/);
+		assert.equal(
+			contents.match(/import \* as __eco_bootstrap_reexport_0 from '\.\/base-layout\.kita';/g)?.length,
+			1,
+		);
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});
+
+test('createNodeBootstrapPlugin fails fast on Bun-only builtins', async () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-bootstrap-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	const importerPath = path.join(rootDir, 'src', 'db.server.ts');
+
+	try {
+		const plugin = createNodeBootstrapPlugin({
+			projectDir: rootDir,
+			runtimeNodeModulesDir: path.join(rootDir, '.eco', 'node_modules'),
+		});
+
+		let onResolveCallback: ((args: { path: string; importer?: string; namespace?: string }) => unknown) | undefined;
+
+		await plugin.setup({
+			onResolve(options, callback) {
+				if (String(options.filter) === String(/^bun:/)) {
+					onResolveCallback = callback;
+				}
+			},
+			onLoad() {},
+			module() {},
+		});
+
+		assert.ok(onResolveCallback);
+		assert.throws(
+			() => onResolveCallback?.({ path: 'bun:sqlite', importer: importerPath }),
+			new RegExp(
+				getNodeUnsupportedBuiltinError('bun:sqlite', importerPath).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
+			),
+		);
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});