ecopages 0.2.0-alpha.9 → 0.2.1

package/README.md

@@ -2,7 +2,7 @@
 
 The official CLI for the Ecopages framework.
 
-It provides scaffolding and development commands to streamline your workflow. It natively wraps your execution environment (Bun or Node) and automatically detects your `eco.config.ts`.
+It provides scaffolding and development commands to streamline your workflow. It prefers Bun when available, falls back to Node otherwise, and automatically detects your `eco.config.ts`.
 
 ## Quick Start
 
@@ -17,15 +17,15 @@ bun dev
 
 ## Commands
 
-| Command                      | Description                                | Equivalent (Bun)                | Equivalent (Node)                             |
-| :--------------------------- | :----------------------------------------- | :------------------------------ | :-------------------------------------------- |
-| `ecopages init <dir>`        | Scaffolds a new project                    | N/A                             | N/A                                           |
-| `ecopages dev [entry]`       | Starts the dev server                      | `bun run [entry] --dev`         | `node [ecopages thin host] [entry] --dev`     |
-| `ecopages dev:watch [entry]` | Dev server + hard restarts on file changes | `bun --watch run [entry] --dev` | `node --watch [ecopages thin host] ...`       |
-| `ecopages dev:hot [entry]`   | Dev server + HMR (no hard restarts)        | `bun --hot run [entry] --dev`   | N/A                                           |
-| `ecopages build [entry]`     | Creates a production build                 | `bun run [entry] --build`       | `node [ecopages thin host] [entry] --build`   |
-| `ecopages start [entry]`     | Starts the production server               | `bun run [entry]`               | `node [ecopages thin host] [entry]`           |
-| `ecopages preview [entry]`   | Previews the production build locally      | `bun run [entry] --preview`     | `node [ecopages thin host] [entry] --preview` |
+| Command                      | Description                                | Equivalent (Bun)                |
+| :--------------------------- | :----------------------------------------- | :------------------------------ |
+| `ecopages init <dir>`        | Scaffolds a new project                    | N/A                             |
+| `ecopages dev [entry]`       | Starts the dev server                      | `bun run [entry] --dev`         |
+| `ecopages dev:watch [entry]` | Dev server + hard restarts on file changes | `bun --watch run [entry] --dev` |
+| `ecopages dev:hot [entry]`   | Dev server + HMR (no hard restarts)        | `bun --hot run [entry] --dev`   |
+| `ecopages build [entry]`     | Creates a production build                 | `bun run [entry] --build`       |
+| `ecopages start [entry]`     | Starts the production server               | `bun run [entry]`               |
+| `ecopages preview [entry]`   | Previews the production build locally      | `bun run [entry] --preview`     |
 
 > [!NOTE]
 > `[entry]` defaults to `app.ts` if not provided.
@@ -34,27 +34,23 @@ bun dev
 
 Server and build commands accept the following options. They automatically map to the equivalent environment variables for the underlying process:
 
-| Option                     | Env Var                 | Description                                               |
-| :------------------------- | :---------------------- | :-------------------------------------------------------- |
-| `-p, --port <port>`        | `ECOPAGES_PORT`         | Server port (default 3000)                                |
-| `-n, --hostname <host>`    | `ECOPAGES_HOSTNAME`     | Server hostname                                           |
-| `-b, --base-url <url>`     | `ECOPAGES_BASE_URL`     | Base URL string                                           |
-| `-d, --debug`              | `ECOPAGES_LOGGER_DEBUG` | Enables debug-level logging                               |
-| `-r, --react-fast-refresh` |                         | Enables React Fast Refresh                                |
-| `--runtime <runtime>`      |                         | Force execution via `bun`, `node`, or `node-experimental` |
+| Option                     | Env Var                 | Description                         |
+| :------------------------- | :---------------------- | :---------------------------------- |
+| `-p, --port <port>`        | `ECOPAGES_PORT`         | Server port (default 3000)          |
+| `-n, --hostname <host>`    | `ECOPAGES_HOSTNAME`     | Server hostname                     |
+| `-b, --base-url <url>`     | `ECOPAGES_BASE_URL`     | Base URL string                     |
+| `-d, --debug`              | `ECOPAGES_LOGGER_DEBUG` | Enables debug-level logging         |
+| `-r, --react-fast-refresh` |                         | Enables React Fast Refresh          |
+| `--runtime <runtime>`      |                         | Force execution via `bun` or `node` |
 
 ### Runtime Detection
 
-The CLI automatically detects your runtime environments by inspecting the package manager (`npm_config_user_agent`) or whether the `Bun` global exists. If neither is forcing Bun, it executes your app through the Ecopages-owned Node thin host.
-
-Both `node` and `node-experimental` now launch through the thin-host boundary and hand off the same serialized Node runtime manifest. `node-experimental` remains available as an explicit verification alias while the unified Node host path continues to settle.
+The CLI prefers Bun when the package manager already indicates Bun, when the `Bun` global is available, or when you force it with `--runtime bun`. Otherwise it falls back to Node.
 
 You can explicitly force the engine using the `--runtime` flag:
 
 ```bash
-ecopages dev --runtime node
 ecopages build --runtime bun
-ecopages dev --runtime node-experimental
 ```
 
 ### Example Usage

package/bin/cli.js

@@ -1,69 +1,24 @@
 #!/usr/bin/env node
 
-import { Command } from 'commander';
+import { defineCommand, runMain } from 'citty';
+import { downloadTemplate } from 'giget';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { join } from 'node:path';
-import tiged from 'tiged';
 import { Logger } from '@ecopages/logger';
 import { createLaunchPlan, launchPlanRequiresExistingEntryFile } from './launch-plan.js';
 
-const logger = new Logger('[ecopages:cli]');
+const logger = new Logger('[ecopages:cli]', { debug: process.env.ECOPAGES_LOGGER_DEBUG === 'true' });
 
-const program = new Command();
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
 
-program.name('ecopages').description('Ecopages CLI utilities').version(pkg.version);
-
-async function handleInit(dir, opts) {
-	const { template, repo } = opts;
-	const targetDir = dir;
-
-	if (existsSync(targetDir)) {
-		logger.error(`Target directory already exists: ${targetDir}`);
-		process.exit(1);
-	}
-
-	logger.info(`Creating target directory '${targetDir}'...`);
-
-	try {
-		const emitter = tiged(`${repo}/examples/${template}`, {
-			disableCache: true,
-			force: true,
-			verbose: false,
-		});
-
-		await emitter.clone(targetDir);
-
-		const pkgPath = join(targetDir, 'package.json');
-		if (existsSync(pkgPath)) {
-			const projectPkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-			projectPkg.name = dir;
-			writeFileSync(pkgPath, JSON.stringify(projectPkg, null, 2) + '\n');
-			logger.info(`Renamed project to '${dir}'`);
-		}
-
-		logger.info('Project initialized! Run `bun install && bun dev` to start.');
-	} catch (err) {
-		logger.error(`Failed to fetch template: ${err.message}`);
-		process.exit(1);
-	}
-}
-
-program
-	.command('init <dir>')
-	.description('Initialize a new project from a template')
-	.option('--template <name>', 'Template name from ecopages/examples/', 'starter-jsx')
-	.option('--repo <repo>', 'GitHub repo (user/repo)', 'ecopages/ecopages')
-	.action(handleInit);
-
 function runLaunchPlan(launchPlan) {
 	if (Object.keys(launchPlan.envOverrides).length > 0) {
-		logger.info(`Environment overrides: ${JSON.stringify(launchPlan.envOverrides)}`);
+		logger.debug(`Environment overrides: ${JSON.stringify(launchPlan.envOverrides)}`);
 	}
 
-	logger.info(`Runtime: ${launchPlan.runtime}`);
-	logger.info(`Running: ${launchPlan.command} ${launchPlan.commandArgs.join(' ')}`);
+	logger.debug(`Runtime: ${launchPlan.runtime}`);
+	logger.debug(`Running: ${launchPlan.command} ${launchPlan.commandArgs.join(' ')}`);
 
 	const child = spawn(launchPlan.command, launchPlan.commandArgs, {
 		stdio: 'inherit',
@@ -73,9 +28,9 @@ function runLaunchPlan(launchPlan) {
 	child.on('error', (error) => {
 		if (error && error.code === 'ENOENT') {
 			const hint =
-				launchPlan.command === 'bun'
+				launchPlan.runtime === 'bun'
 					? 'Install Bun from https://bun.sh to continue.'
-					: 'Install Node.js and ensure the `node` command is available to continue.';
+					: 'Reinstall ecopages and its dependencies so the packaged tsx runtime is available for Node.js launches.';
 			logger.error(`Command not found: ${launchPlan.command}. ${hint}`);
 			process.exit(1);
 		}
@@ -90,14 +45,22 @@ function runLaunchPlan(launchPlan) {
 }
 
 /**
- * Execute a bun command with the given arguments and options.
+ * Launch the entry file via the detected or forced runtime (bun or node).
  * Automatically detects eco.config.ts and applies preloads.
  * @param {string[]} args - Arguments to pass to the entry file
  * @param {object} options - CLI options (watch, hot, port, hostname, etc.)
  * @param {string} entryFile - Entry file to run
  */
-async function runBunCommand(args, options = {}, entryFile = 'app.ts') {
-	const launchPlan = await createLaunchPlan(args, options, entryFile);
+async function runEntryCommand(args, options = {}, entryFile = 'app.ts') {
+	let launchPlan;
+
+	try {
+		launchPlan = await createLaunchPlan(args, options, entryFile);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.error(message);
+		process.exit(1);
+	}
 
 	if (launchPlanRequiresExistingEntryFile(launchPlan) && !existsSync(entryFile)) {
 		logger.error(`Error: Entry file "${entryFile}" not found in the current directory.`);
@@ -107,63 +70,191 @@ async function runBunCommand(args, options = {}, entryFile = 'app.ts') {
 	runLaunchPlan(launchPlan);
 }
 
-/**
- * Add shared server options to a command.
- * @param {import('commander').Command} cmd - The command to add options to
- * @returns {import('commander').Command} The command with options added
- */
-const serverOptions = (cmd) =>
-	cmd
-		.option('-p, --port <port>', 'Override ECOPAGES_PORT')
-		.option('-n, --hostname <hostname>', 'Override ECOPAGES_HOSTNAME')
-		.option('-b, --base-url <url>', 'Override ECOPAGES_BASE_URL')
-		.option('-d, --debug', 'Enable debug logging (ECOPAGES_LOGGER_DEBUG=true)')
-		.option('-r, --react-fast-refresh', 'Enable React Fast Refresh for HMR')
-		.option('--runtime <runtime>', 'Force a specific runtime (bun, node, or node-experimental)');
-
-serverOptions(
-	program.command('dev').description('Start the development server').argument('[entry]', 'Entry file', 'app.ts'),
-).action(async (entry, opts) => {
-	await runBunCommand(['--dev'], { ...opts, nodeEnv: 'development' }, entry);
+/** Shared server argument definitions for citty commands. */
+const serverArgs = {
+	entry: {
+		type: 'positional',
+		description: 'Entry file',
+		default: 'app.ts',
+	},
+	port: {
+		type: 'string',
+		alias: ['p'],
+		description: 'Override ECOPAGES_PORT',
+	},
+	hostname: {
+		type: 'string',
+		alias: ['n'],
+		description: 'Override ECOPAGES_HOSTNAME',
+	},
+	'base-url': {
+		type: 'string',
+		alias: ['b'],
+		description: 'Override ECOPAGES_BASE_URL',
+	},
+	debug: {
+		type: 'boolean',
+		alias: ['d'],
+		description: 'Enable debug logging (ECOPAGES_LOGGER_DEBUG=true)',
+	},
+	'react-fast-refresh': {
+		type: 'boolean',
+		alias: ['r'],
+		description: 'Enable React Fast Refresh for HMR',
+	},
+	runtime: {
+		type: 'string',
+		description: 'Force a specific runtime (bun or node)',
+	},
+};
+
+const initCommand = defineCommand({
+	meta: {
+		name: 'init',
+		description: 'Initialize a new project from a template',
+	},
+	args: {
+		dir: {
+			type: 'positional',
+			description: 'Target directory name',
+			required: true,
+		},
+		template: {
+			type: 'string',
+			description: 'Template name from ecopages/examples/',
+			default: 'starter-jsx',
+		},
+		repo: {
+			type: 'string',
+			description: 'GitHub repo (user/repo)',
+			default: 'ecopages/ecopages',
+		},
+	},
+	async run({ args }) {
+		const { dir, template, repo } = args;
+
+		if (existsSync(dir)) {
+			logger.error(`Target directory already exists: ${dir}`);
+			process.exit(1);
+		}
+
+		logger.info(`Creating target directory '${dir}'...`);
+
+		try {
+			await downloadTemplate(`github:${repo}/examples/${template}`, {
+				dir,
+				force: true,
+			});
+
+			const pkgPath = join(dir, 'package.json');
+			if (existsSync(pkgPath)) {
+				const projectPkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+				projectPkg.name = dir;
+				writeFileSync(pkgPath, JSON.stringify(projectPkg, null, 2) + '\n');
+				logger.info(`Renamed project to '${dir}'`);
+			}
+
+			logger.info('Project initialized! Run `bun install && bun dev` to start.');
+		} catch (err) {
+			logger.error(`Failed to fetch template: ${err.message}`);
+			process.exit(1);
+		}
+	},
 });
 
-serverOptions(
-	program
-		.command('dev:watch')
-		.description('Start the development server with watch mode (restarts on file changes)')
-		.argument('[entry]', 'Entry file', 'app.ts'),
-).action(async (entry, opts) => {
-	await runBunCommand(['--dev'], { ...opts, watch: true, nodeEnv: 'development' }, entry);
+const devCommand = defineCommand({
+	meta: {
+		name: 'dev',
+		description: 'Start the development server',
+	},
+	args: serverArgs,
+	async run({ args }) {
+		await runEntryCommand(['--dev'], { ...args, nodeEnv: 'development' }, args.entry);
+	},
 });
 
-serverOptions(
-	program
-		.command('dev:hot')
-		.description('Start the development server with hot reload (HMR without restart)')
-		.argument('[entry]', 'Entry file', 'app.ts'),
-).action(async (entry, opts) => {
-	await runBunCommand(['--dev'], { ...opts, hot: true, nodeEnv: 'development' }, entry);
+const devWatchCommand = defineCommand({
+	meta: {
+		name: 'dev:watch',
+		description: 'Start the development server with watch mode (restarts on file changes)',
+	},
+	args: serverArgs,
+	async run({ args }) {
+		await runEntryCommand(['--dev'], { ...args, watch: true, nodeEnv: 'development' }, args.entry);
+	},
 });
 
-program
-	.command('build')
-	.description('Build the project for production')
-	.argument('[entry]', 'Entry file', 'app.ts')
-	.option('--runtime <runtime>', 'Force a specific runtime (bun, node, or node-experimental)')
-	.action(async (entry, opts) => {
-		await runBunCommand(['--build'], { nodeEnv: 'production', ...opts }, entry);
-	});
+const devHotCommand = defineCommand({
+	meta: {
+		name: 'dev:hot',
+		description: 'Start the development server with hot reload (HMR without restart)',
+	},
+	args: serverArgs,
+	async run({ args }) {
+		await runEntryCommand(['--dev'], { ...args, hot: true, nodeEnv: 'development' }, args.entry);
+	},
+});
 
-serverOptions(
-	program.command('start').description('Start the production server').argument('[entry]', 'Entry file', 'app.ts'),
-).action(async (entry, opts) => {
-	await runBunCommand([], { ...opts, nodeEnv: 'production' }, entry);
+const buildCommand = defineCommand({
+	meta: {
+		name: 'build',
+		description: 'Build the project for production',
+	},
+	args: {
+		entry: {
+			type: 'positional',
+			description: 'Entry file',
+			default: 'app.ts',
+		},
+		runtime: {
+			type: 'string',
+			description: 'Force a specific runtime (bun or node)',
+		},
+	},
+	async run({ args }) {
+		await runEntryCommand(['--build'], { nodeEnv: 'production', ...args }, args.entry);
+	},
 });
 
-serverOptions(
-	program.command('preview').description('Preview the production build').argument('[entry]', 'Entry file', 'app.ts'),
-).action(async (entry, opts) => {
-	await runBunCommand(['--preview'], { ...opts, nodeEnv: 'production' }, entry);
+const startCommand = defineCommand({
+	meta: {
+		name: 'start',
+		description: 'Start the production server',
+	},
+	args: serverArgs,
+	async run({ args }) {
+		await runEntryCommand([], { ...args, nodeEnv: 'production' }, args.entry);
+	},
 });
 
-program.parse();
+const previewCommand = defineCommand({
+	meta: {
+		name: 'preview',
+		description: 'Preview the production build',
+	},
+	args: serverArgs,
+	async run({ args }) {
+		await runEntryCommand(['--preview'], { ...args, nodeEnv: 'production' }, args.entry);
+	},
+});
+
+export const mainCommand = defineCommand({
+	meta: {
+		name: 'ecopages',
+		version: pkg.version,
+		description: 'Ecopages CLI utilities',
+	},
+	subCommands: {
+		init: initCommand,
+		dev: devCommand,
+		'dev:watch': devWatchCommand,
+		'dev:hot': devHotCommand,
+		build: buildCommand,
+		start: startCommand,
+		preview: previewCommand,
+	},
+});
+
+if (!process.env.VITEST) {
+	runMain(mainCommand);
+}

package/bin/cli.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { runCommand } from 'citty';
+import { mainCommand } from './cli.js';
+import * as giget from 'giget';
+import * as fs from 'node:fs';
+import * as launchPlan from './launch-plan.js';
+
+vi.mock('giget', () => ({
+	downloadTemplate: vi.fn(),
+}));
+
+vi.mock('node:fs', async (importOriginal) => {
+	const actual = await importOriginal<typeof import('node:fs')>();
+	return {
+		...actual,
+		existsSync: vi.fn((path) => actual.existsSync(path)),
+		writeFileSync: vi.fn(),
+	};
+});
+
+vi.mock('./launch-plan.js', () => ({
+	createLaunchPlan: vi.fn(),
+	launchPlanRequiresExistingEntryFile: vi.fn(),
+}));
+
+vi.mock('node:child_process', () => ({
+	spawn: vi.fn().mockImplementation(() => ({
+		on: vi.fn(),
+	})),
+}));
+
+vi.mock('@ecopages/logger', () => ({
+	Logger: class {
+		info = vi.fn();
+		warn = vi.fn();
+		error = vi.fn();
+		debug = vi.fn();
+	},
+}));
+
+describe('CLI Commands', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+
+		// Default mocks
+		vi.mocked(fs.existsSync).mockReturnValue(false); // pretend no existing dir
+		vi.mocked(launchPlan.createLaunchPlan).mockResolvedValue({
+			runtime: 'node',
+			command: 'node',
+			commandArgs: [],
+			envOverrides: {},
+			env: {},
+		} as any);
+		vi.mocked(launchPlan.launchPlanRequiresExistingEntryFile).mockReturnValue(false);
+	});
+
+	it('runs init command with default template and repo', async () => {
+		await runCommand(mainCommand, { rawArgs: ['init', 'my-new-project'] });
+		expect(giget.downloadTemplate).toHaveBeenCalledWith('github:ecopages/ecopages/examples/starter-jsx', {
+			dir: 'my-new-project',
+			force: true,
+		});
+	});
+
+	it('runs init command with custom template and repo', async () => {
+		await runCommand(mainCommand, {
+			rawArgs: ['init', 'my-dir', '--template', 'starter-lit', '--repo', 'custom/repo'],
+		});
+		expect(giget.downloadTemplate).toHaveBeenCalledWith('github:custom/repo/examples/starter-lit', {
+			dir: 'my-dir',
+			force: true,
+		});
+	});
+
+	it('runs dev command and passes defaults to launch plan', async () => {
+		await runCommand(mainCommand, { rawArgs: ['dev'] });
+		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
+			['--dev'],
+			expect.objectContaining({ nodeEnv: 'development' }),
+			'app.ts',
+		);
+	});
+
+	it('runs dev:hot command', async () => {
+		await runCommand(mainCommand, { rawArgs: ['dev:hot'] });
+		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
+			['--dev'],
+			expect.objectContaining({ hot: true, nodeEnv: 'development' }),
+			'app.ts',
+		);
+	});
+
+	it('runs dev:watch command', async () => {
+		await runCommand(mainCommand, { rawArgs: ['dev:watch'] });
+		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
+			['--dev'],
+			expect.objectContaining({ watch: true, nodeEnv: 'development' }),
+			'app.ts',
+		);
+	});
+
+	it('runs build command with custom entry file', async () => {
+		await runCommand(mainCommand, { rawArgs: ['build', 'server.ts'] });
+		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
+			['--build'],
+			expect.objectContaining({ nodeEnv: 'production' }),
+			'server.ts',
+		);
+	});
+
+	it('passes shared server options like port and hostname correctly', async () => {
+		await runCommand(mainCommand, { rawArgs: ['start', '-p', '4000', '--hostname', '0.0.0.0'] });
+		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
+			[],
+			expect.objectContaining({
+				nodeEnv: 'production',
+				port: '4000',
+				hostname: '0.0.0.0',
+			}),
+			'app.ts',
+		);
+	});
+
+	it('allows overriding base url and debug options', async () => {
+		await runCommand(mainCommand, { rawArgs: ['preview', '--base-url', '/my-app/', '-d'] });
+		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
+			['--preview'],
+			expect.objectContaining({
+				nodeEnv: 'production',
+				'base-url': '/my-app/',
+				debug: true,
+			}),
+			'app.ts',
+		);
+	});
+});

package/bin/launch-plan.js

@@ -1,9 +1,7 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
 
-const NODE_THIN_HOST_PATH = fileURLToPath(new URL('./node-thin-host.js', import.meta.url));
-const DEFAULT_INTERNAL_WORK_DIR = '.eco';
+const require = createRequire(import.meta.url);
 
 export function buildEnvOverrides(options) {
 	const env = {};
@@ -16,7 +14,7 @@ export function buildEnvOverrides(options) {
 }
 
 export function detectRuntime(options = {}) {
-	if (options.runtime === 'bun' || options.runtime === 'node' || options.runtime === 'node-experimental') {
+	if (options.runtime === 'bun' || options.runtime === 'node') {
 		return options.runtime;
 	}
 
@@ -42,7 +40,7 @@ export function buildBunArgs(args, options, entryFile, hasConfig) {
 	bunArgs.push('run');
 
 	if (hasConfig) {
-		bunArgs.push('--preload', 'eco.config.ts');
+		bunArgs.push('--preload', './eco.config.ts');
 	}
 
 	bunArgs.push(entryFile, ...args);
@@ -54,12 +52,14 @@ export function buildBunArgs(args, options, entryFile, hasConfig) {
 	return bunArgs;
 }
 
-export function buildNodeArgs(args, options, entryFile) {
+export function buildNodeArgs(args, options, entryFile, hasConfig) {
 	const nodeArgs = [];
 
-	if (options.watch) nodeArgs.push('--watch');
+	if (hasConfig) {
+		nodeArgs.push('--import', './eco.config.ts');
+	}
 
-	nodeArgs.push(NODE_THIN_HOST_PATH, entryFile, ...args);
+	nodeArgs.push(entryFile, ...args);
 
 	if (options.reactFastRefresh) {
 		nodeArgs.push('--react-fast-refresh');
@@ -68,41 +68,14 @@ export function buildNodeArgs(args, options, entryFile) {
 	return nodeArgs;
 }
 
-export function resolveNodeRuntimeManifestPath(projectDir = process.cwd()) {
-	return path.join(path.resolve(projectDir), DEFAULT_INTERNAL_WORK_DIR, 'runtime', 'node-runtime-manifest.json');
-}
-
-export async function createNodeRuntimeManifestFile(
-	entryFile,
-	options = {
-		cwd: process.cwd(),
-		env: process.env,
-	},
-) {
-	const projectDir = path.resolve(options.cwd ?? process.cwd());
-	const configPath = path.join(projectDir, 'eco.config.ts');
-	const manifestFilePath = options.manifestFilePath ?? resolveNodeRuntimeManifestPath(projectDir);
-
-	if (!existsSync(configPath)) {
-		throw new Error('The Node thin-host runtime requires eco.config.ts in the current project root.');
+export function resolveTsxCliPath() {
+	try {
+		return require.resolve('tsx/cli');
+	} catch {
+		throw new Error(
+			'Unable to resolve the packaged tsx runtime required for Node.js launches. Reinstall ecopages and its dependencies, or use the Bun runtime instead.',
+		);
 	}
-
-	const manifest = {
-		runtime: 'node',
-		appRootDir: projectDir,
-		sourceRootDir: path.join(projectDir, 'src'),
-		distDir: path.join(projectDir, 'dist'),
-		workDir: path.join(projectDir, DEFAULT_INTERNAL_WORK_DIR),
-		modulePaths: {
-			config: configPath,
-			entry: path.resolve(projectDir, entryFile),
-		},
-	};
-
-	mkdirSync(path.dirname(manifestFilePath), { recursive: true });
-	writeFileSync(manifestFilePath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
-
-	return manifestFilePath;
 }
 
 export async function createLaunchPlan(args, options = {}, entryFile = 'app.ts') {
@@ -111,19 +84,16 @@ export async function createLaunchPlan(args, options = {}, entryFile = 'app.ts')
 	const runtime = detectRuntime(options);
 	const env = { ...process.env, ...envOverrides };
 
-	if (runtime === 'node' || runtime === 'node-experimental') {
-		const manifestFilePath = await createNodeRuntimeManifestFile(entryFile, { env });
+	if (runtime === 'node') {
+		const tsxCliPath = resolveTsxCliPath();
 
 		return {
 			runtime,
-			executionStrategy: 'node-thin-host',
-			command: 'node',
-			commandArgs: buildNodeArgs(args, options, entryFile),
+			executionStrategy: 'direct-runtime',
+			command: process.execPath,
+			commandArgs: [tsxCliPath, ...buildNodeArgs(args, options, entryFile, hasConfig)],
 			envOverrides,
-			env: {
-				...env,
-				ECOPAGES_NODE_RUNTIME_MANIFEST_PATH: manifestFilePath,
-			},
+			env,
 		};
 	}
 

package/bin/launch-plan.test.ts

@@ -1,18 +1,20 @@
 import fs from 'node:fs';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 import { tmpdir } from 'node:os';
 import { afterEach, describe, expect, it } from 'vitest';
 import {
 	buildEnvOverrides,
-	buildNodeArgs,
 	buildBunArgs,
-	createNodeRuntimeManifestFile,
+	buildNodeArgs,
 	createLaunchPlan,
 	detectRuntime,
 	launchPlanRequiresExistingEntryFile,
-	resolveNodeRuntimeManifestPath,
+	resolveTsxCliPath,
 } from './launch-plan.js';
 
+const require = createRequire(import.meta.url);
+
 const originalUserAgent = process.env.npm_config_user_agent;
 
 afterEach(() => {
@@ -46,27 +48,6 @@ describe('launch-plan', () => {
 		);
 	}
 
-	function writeImportMetaRuntimeConfig(tempDir) {
-		fs.writeFileSync(
-			path.join(tempDir, 'eco.config.ts'),
-			[
-				"import path from 'node:path';",
-				'export default {',
-				'\trootDir: import.meta.dirname,',
-				'\tloaders: new Map(),',
-				'\tabsolutePaths: {',
-				"\t\tconfig: path.join(import.meta.dirname, 'eco.config.ts'),",
-				"\t\tsrcDir: path.join(import.meta.dirname, 'src'),",
-				"\t\tdistDir: path.join(import.meta.dirname, 'dist'),",
-				"\t\tworkDir: path.join(import.meta.dirname, '.eco'),",
-				'\t},',
-				'\truntime: {},',
-				'};',
-			].join('\n'),
-			'utf8',
-		);
-	}
-
 	it('buildEnvOverrides maps CLI options onto environment variables', () => {
 		expect(
 			buildEnvOverrides({
@@ -85,31 +66,11 @@ describe('launch-plan', () => {
 		});
 	});
 
-	it('detectRuntime defaults to node unless bun is explicit', () => {
+	it('detectRuntime returns node when Bun is not available', () => {
 		process.env.npm_config_user_agent = 'pnpm/10.0.0 npm/? node/v24.0.0 darwin arm64';
 		expect(detectRuntime()).toBe('node');
 		expect(detectRuntime({ runtime: 'bun' })).toBe('bun');
 		expect(detectRuntime({ runtime: 'node' })).toBe('node');
-		expect(detectRuntime({ runtime: 'node-experimental' })).toBe('node-experimental');
-	});
-
-	it('buildNodeArgs preserves watch mode and fast refresh flags', () => {
-		expect(buildNodeArgs(['--dev'], { watch: true, reactFastRefresh: true }, 'app.ts')).toEqual([
-			'--watch',
-			expect.stringMatching(/node-thin-host\.js$/),
-			'app.ts',
-			'--dev',
-			'--react-fast-refresh',
-		]);
-	});
-
-	it('buildNodeArgs routes stable Node through the thin launcher', () => {
-		expect(buildNodeArgs(['--dev'], { watch: true }, 'app.ts')).toEqual([
-			'--watch',
-			expect.stringMatching(/node-thin-host\.js$/),
-			'app.ts',
-			'--dev',
-		]);
 	});
 
 	it('buildBunArgs preloads eco.config.ts when present', () => {
@@ -117,66 +78,45 @@ describe('launch-plan', () => {
 			'--hot',
 			'run',
 			'--preload',
-			'eco.config.ts',
+			'./eco.config.ts',
 			'app.ts',
 			'--dev',
 		]);
 	});
 
-	it('createLaunchPlan routes node app launches through the thin host', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.env.npm_config_user_agent = 'pnpm/10.0.0 npm/? node/v24.0.0 darwin arm64';
-			process.chdir(tempDir);
-			writeExperimentalRuntimeConfig(tempDir);
-			fs.writeFileSync(
-				path.join(tempDir, 'app.ts'),
-				[
-					"import { EcopagesApp } from '@ecopages/core';",
-					"import appConfig from './eco.config';",
-					'const app = new EcopagesApp({ appConfig });',
-					'await app.start();',
-				].join('\n'),
-				'utf8',
-			);
-			const plan = await createLaunchPlan(['--dev'], { watch: true, nodeEnv: 'development' }, 'app.ts');
+	it('buildNodeArgs imports eco.config.ts when present', () => {
+		expect(buildNodeArgs(['--dev'], {}, 'app.ts', true)).toEqual([
+			'--import',
+			'./eco.config.ts',
+			'app.ts',
+			'--dev',
+		]);
+	});
 
-			expect(plan).toMatchObject({
-				runtime: 'node',
-				executionStrategy: 'node-thin-host',
-				command: 'node',
-				envOverrides: { NODE_ENV: 'development' },
-			});
-			expect(plan.commandArgs).toEqual([
-				'--watch',
-				expect.stringMatching(/node-thin-host\.js$/),
-				'app.ts',
-				'--dev',
-			]);
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
+	it('resolveTsxCliPath resolves the packaged tsx cli entry', () => {
+		expect(resolveTsxCliPath()).toBe(require.resolve('tsx/cli'));
 	});
 
-	it('createLaunchPlan preserves direct node entrypoints on the thin-host path', async () => {
+	it('createLaunchPlan uses the packaged tsx cli for node runtime', async () => {
 		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
 		try {
 			process.env.npm_config_user_agent = 'pnpm/10.0.0 npm/? node/v24.0.0 darwin arm64';
 			process.chdir(tempDir);
-			fs.writeFileSync(path.join(tempDir, 'server.ts'), 'await Promise.resolve();', 'utf8');
+			fs.writeFileSync(path.join(tempDir, 'app.ts'), 'await Promise.resolve();', 'utf8');
 			writeExperimentalRuntimeConfig(tempDir);
 
-			const plan = await createLaunchPlan(['--dev'], { watch: true }, 'server.ts');
+			const plan = await createLaunchPlan(['--dev'], { runtime: 'node', nodeEnv: 'development' }, 'app.ts');
 
 			expect(plan).toMatchObject({
 				runtime: 'node',
-				executionStrategy: 'node-thin-host',
-				command: 'node',
+				executionStrategy: 'direct-runtime',
+				command: process.execPath,
 			});
 			expect(plan.commandArgs).toEqual([
-				'--watch',
-				expect.stringMatching(/node-thin-host\.js$/),
-				'server.ts',
+				require.resolve('tsx/cli'),
+				'--import',
+				'./eco.config.ts',
+				'app.ts',
 				'--dev',
 			]);
 		} finally {
@@ -198,90 +138,7 @@ describe('launch-plan', () => {
 				executionStrategy: 'direct-runtime',
 				command: 'bun',
 			});
-			expect(plan.commandArgs).toEqual(['run', '--preload', 'eco.config.ts', 'app.ts', '--preview']);
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('createNodeRuntimeManifestFile writes the core-owned manifest under .eco/runtime', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.chdir(tempDir);
-			writeExperimentalRuntimeConfig(tempDir);
-			const manifestFilePath = await createNodeRuntimeManifestFile('app.ts');
-			const manifest = JSON.parse(fs.readFileSync(manifestFilePath, 'utf8'));
-			const resolvedTempDir = fs.realpathSync(tempDir);
-
-			expect(manifestFilePath).toBe(resolveNodeRuntimeManifestPath(resolvedTempDir));
-			expect(manifest).toMatchObject({
-				runtime: 'node',
-				appRootDir: resolvedTempDir,
-				sourceRootDir: path.join(resolvedTempDir, 'src'),
-				distDir: path.join(resolvedTempDir, 'dist'),
-				workDir: path.join(resolvedTempDir, '.eco'),
-				modulePaths: {
-					config: path.join(resolvedTempDir, 'eco.config.ts'),
-					entry: path.join(resolvedTempDir, 'app.ts'),
-				},
-			});
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('createNodeRuntimeManifestFile does not evaluate eco.config.ts while writing the manifest', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.chdir(tempDir);
-			writeImportMetaRuntimeConfig(tempDir);
-			const manifestFilePath = await createNodeRuntimeManifestFile('app.ts');
-			const manifest = JSON.parse(fs.readFileSync(manifestFilePath, 'utf8'));
-			const resolvedTempDir = fs.realpathSync(tempDir);
-
-			expect(manifestFilePath).toBe(resolveNodeRuntimeManifestPath(resolvedTempDir));
-			expect(manifest).toMatchObject({
-				appRootDir: resolvedTempDir,
-				sourceRootDir: path.join(resolvedTempDir, 'src'),
-				distDir: path.join(resolvedTempDir, 'dist'),
-				workDir: path.join(resolvedTempDir, '.eco'),
-				modulePaths: {
-					config: path.join(resolvedTempDir, 'eco.config.ts'),
-					entry: path.join(resolvedTempDir, 'app.ts'),
-				},
-			});
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('createLaunchPlan routes node-experimental through the thin host launcher', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.chdir(tempDir);
-			writeExperimentalRuntimeConfig(tempDir);
-			const resolvedTempDir = fs.realpathSync(tempDir);
-			const plan = await createLaunchPlan(
-				['--dev'],
-				{ runtime: 'node-experimental', nodeEnv: 'development' },
-				'app.ts',
-			);
-
-			expect(plan).toMatchObject({
-				runtime: 'node-experimental',
-				executionStrategy: 'node-thin-host',
-				command: 'node',
-				envOverrides: { NODE_ENV: 'development' },
-			});
-			expect(plan.commandArgs).toEqual([expect.stringMatching(/node-thin-host\.js$/), 'app.ts', '--dev']);
-			expect(plan.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH).toBe(resolveNodeRuntimeManifestPath(resolvedTempDir));
-			expect(JSON.parse(fs.readFileSync(plan.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH, 'utf8'))).toMatchObject({
-				runtime: 'node',
-				modulePaths: {
-					config: path.join(resolvedTempDir, 'eco.config.ts'),
-					entry: path.join(resolvedTempDir, 'app.ts'),
-				},
-			});
+			expect(plan.commandArgs).toEqual(['run', '--preload', './eco.config.ts', 'app.ts', '--preview']);
 		} finally {
 			fs.rmSync(tempDir, { recursive: true, force: true });
 		}
@@ -290,25 +147,12 @@ describe('launch-plan', () => {
 	it('launchPlanRequiresExistingEntryFile requires a concrete entry on every runtime path', async () => {
 		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
 		try {
-			process.env.npm_config_user_agent = 'pnpm/10.0.0 npm/? node/v24.0.0 darwin arm64';
 			process.chdir(tempDir);
 			fs.writeFileSync(path.join(tempDir, 'app.ts'), 'await Promise.resolve();', 'utf8');
 			writeExperimentalRuntimeConfig(tempDir);
 
-			const nodePlan = await createLaunchPlan(['--dev'], { nodeEnv: 'development' }, 'app.ts');
-			expect(nodePlan.executionStrategy).toBe('node-thin-host');
-			expect(launchPlanRequiresExistingEntryFile(nodePlan)).toBe(true);
-
-			fs.writeFileSync(path.join(tempDir, 'server.ts'), 'await Promise.resolve();', 'utf8');
-			const directNodePlan = await createLaunchPlan(['--dev'], { nodeEnv: 'development' }, 'server.ts');
-			expect(directNodePlan.executionStrategy).toBe('node-thin-host');
-			expect(launchPlanRequiresExistingEntryFile(directNodePlan)).toBe(true);
-
-			const bunPlan = await createLaunchPlan(['--dev'], { runtime: 'bun' }, 'app.ts');
+			const bunPlan = await createLaunchPlan(['--dev'], { nodeEnv: 'development' }, 'app.ts');
 			expect(launchPlanRequiresExistingEntryFile(bunPlan)).toBe(true);
-
-			const experimentalNodePlan = await createLaunchPlan(['--dev'], { runtime: 'node-experimental' }, 'app.ts');
-			expect(launchPlanRequiresExistingEntryFile(experimentalNodePlan)).toBe(true);
 		} finally {
 			fs.rmSync(tempDir, { recursive: true, force: true });
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ecopages",
-  "version": "0.2.0-alpha.9",
+  "version": "0.2.1",
   "description": "CLI utilities for Ecopages",
   "type": "module",
   "license": "MIT",
@@ -35,10 +35,10 @@
   ],
   "dependencies": {
     "@ecopages/core": "workspace:*",
-    "esbuild": "^0.27.3",
-    "commander": "^12.1.0",
-    "tiged": "^2.12.7",
-    "@ecopages/logger": "^0.2.2"
+    "@ecopages/logger": "^0.2.2",
+    "citty": "^0.1.6",
+    "giget": "^2.0.0",
+    "tsx": "^4.21.0"
   },
   "peerDependencies": {
     "bun-types": "*",

package/bin/node-thin-host.js

@@ -1,138 +0,0 @@
-#!/usr/bin/env node
-
-import { readFileSync } from 'node:fs';
-import { Logger } from '@ecopages/logger';
-import { assertNodeRuntimeManifest, createNodeRuntimeAdapter } from '@ecopages/core/node/runtime-adapter';
-import { fileURLToPath } from 'node:url';
-
-const logger = new Logger('[ecopages:node-thin-host]');
-
-function formatErrorForLog(error) {
-	if (error instanceof Error) {
-		return error.stack ?? error.message;
-	}
-
-	return String(error);
-}
-
-function attachShutdownHandlers(session) {
-	let shutdownPromise;
-
-	const shutdown = async (signal) => {
-		if (!shutdownPromise) {
-			shutdownPromise = (async () => {
-				try {
-					logger.info(`Received ${signal}. Shutting down Node thin-host runtime.`);
-					await session.dispose();
-				} catch (error) {
-					logger.error(formatErrorForLog(error));
-				} finally {
-					process.exit(0);
-				}
-			})();
-		}
-
-		await shutdownPromise;
-	};
-
-	process.once('SIGINT', () => {
-		void shutdown('SIGINT');
-	});
-	process.once('SIGTERM', () => {
-		void shutdown('SIGTERM');
-	});
-}
-
-/**
- * Creates the host-to-adapter handoff payload for the Node thin-host runtime.
- */
-export function createRuntimeStartOptions(options = {}) {
-	return {
-		manifest: options.manifest ?? readRuntimeManifest(),
-		workingDirectory: options.workingDirectory ?? process.cwd(),
-		cliArgs: options.cliArgs ?? process.argv.slice(2),
-	};
-}
-
-export function readRuntimeManifest() {
-	const manifestFilePath = process.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH;
-
-	if (!manifestFilePath) {
-		throw new Error('Missing ECOPAGES_NODE_RUNTIME_MANIFEST_PATH for Node thin-host launch.');
-	}
-
-	let serializedManifest;
-
-	try {
-		serializedManifest = readFileSync(manifestFilePath, 'utf8');
-	} catch (error) {
-		throw new Error(
-			`Failed to read ECOPAGES_NODE_RUNTIME_MANIFEST_PATH at ${manifestFilePath}: ${error instanceof Error ? error.message : String(error)}`,
-		);
-	}
-
-	let parsedManifest;
-
-	try {
-		parsedManifest = JSON.parse(serializedManifest);
-	} catch (error) {
-		throw new Error(
-			`Invalid Node runtime manifest JSON: ${error instanceof Error ? error.message : String(error)}`,
-		);
-	}
-
-	return assertNodeRuntimeManifest(parsedManifest);
-}
-
-/**
- * Starts the Node thin-host runtime by delegating validated input to the
- * adapter boundary.
- *
- * @remarks
- * This function intentionally keeps the thin host transport-oriented. It does
- * not own framework bootstrap policy beyond reading the manifest, creating the
- * adapter, and delegating startup plus shutdown lifecycle.
- */
-export async function startThinHostRuntime(options = {}) {
-	const adapter = options.adapter ?? createNodeRuntimeAdapter();
-	const startOptions = createRuntimeStartOptions(options);
-	const session = await adapter.start(startOptions);
-	let loadedAppRuntime;
-
-	try {
-		loadedAppRuntime = await session.loadApp();
-	} catch (error) {
-		try {
-			await session.dispose();
-		} catch (disposeError) {
-			throw new Error(
-				`Failed to dispose Node thin-host runtime session after bootstrap error: ${disposeError instanceof Error ? disposeError.message : String(disposeError)}`,
-				{ cause: error instanceof Error ? error : undefined },
-			);
-		}
-
-		throw error;
-	}
-
-	if (options.attachShutdownHandlers !== false) {
-		attachShutdownHandlers(session);
-	}
-
-	return {
-		session,
-		loadedAppRuntime,
-	};
-}
-
-async function main() {
-	try {
-		await startThinHostRuntime();
-	} catch (error) {
-		logger.error(formatErrorForLog(error));
-		process.exit(1);
-	}
-}
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	await main();
-}

package/bin/node-thin-host.test.ts

@@ -1,167 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { createRuntimeStartOptions, readRuntimeManifest, startThinHostRuntime } from './node-thin-host.js';
-
-const originalManifestPath = process.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH;
-
-afterEach(() => {
-	if (originalManifestPath === undefined) {
-		delete process.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH;
-	} else {
-		process.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH = originalManifestPath;
-	}
-});
-
-describe('node-thin-host', () => {
-	it('reads, validates, and returns the runtime manifest from the file handoff', () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-node-thin-host-'));
-		const manifestFilePath = path.join(tempDir, 'node-runtime-manifest.json');
-
-		try {
-			fs.writeFileSync(
-				manifestFilePath,
-				JSON.stringify({
-					runtime: 'node',
-					appRootDir: '/repo',
-					sourceRootDir: '/repo/src',
-					distDir: '/repo/dist',
-					workDir: '/repo/.eco',
-					modulePaths: {
-						config: '/repo/eco.config.ts',
-						entry: '/repo/app.ts',
-					},
-				}),
-				'utf8',
-			);
-
-			process.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH = manifestFilePath;
-
-			expect(readRuntimeManifest()).toMatchObject({
-				modulePaths: {
-					entry: '/repo/app.ts',
-				},
-			});
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('creates the adapter handoff from validated manifest plus process launch context', () => {
-		const manifest = {
-			runtime: 'node',
-			appRootDir: '/repo',
-			sourceRootDir: '/repo/src',
-			distDir: '/repo/dist',
-			workDir: '/repo/.eco',
-			modulePaths: {
-				config: '/repo/eco.config.ts',
-				entry: '/repo/app.ts',
-			},
-		};
-
-		expect(
-			createRuntimeStartOptions({
-				manifest,
-				workingDirectory: '/repo',
-				cliArgs: ['app.ts', '--dev'],
-			}),
-		).toEqual({
-			manifest,
-			workingDirectory: '/repo',
-			cliArgs: ['app.ts', '--dev'],
-		});
-	});
-
-	it('delegates startup to the adapter boundary and returns the loaded runtime session', async () => {
-		const session = {
-			loadApp: vi.fn(async () => ({
-				manifest: { runtime: 'node' },
-				workingDirectory: '/repo',
-				appConfig: { rootDir: '/repo' },
-				entryModulePath: '/repo/app.ts',
-				entryModule: { default: true },
-			})),
-			dispose: vi.fn(async () => undefined),
-		};
-		const adapter = {
-			start: vi.fn(async () => session),
-		};
-		const manifest = {
-			runtime: 'node',
-			appRootDir: '/repo',
-			sourceRootDir: '/repo/src',
-			distDir: '/repo/dist',
-			workDir: '/repo/.eco',
-			modulePaths: {
-				config: '/repo/eco.config.ts',
-				entry: '/repo/app.ts',
-			},
-		};
-
-		const runtime = await startThinHostRuntime({
-			adapter,
-			manifest,
-			workingDirectory: '/repo',
-			cliArgs: ['app.ts', '--dev'],
-			attachShutdownHandlers: false,
-		});
-
-		expect(adapter.start).toHaveBeenCalledWith({
-			manifest,
-			workingDirectory: '/repo',
-			cliArgs: ['app.ts', '--dev'],
-		});
-		expect(session.loadApp).toHaveBeenCalledTimes(1);
-		expect(runtime).toMatchObject({
-			loadedAppRuntime: {
-				entryModulePath: '/repo/app.ts',
-				appConfig: { rootDir: '/repo' },
-			},
-			session,
-		});
-	});
-
-	it('disposes the runtime session if app bootstrap fails after adapter startup', async () => {
-		const bootstrapError = new Error('bootstrap failed');
-		const session = {
-			loadApp: vi.fn(async () => {
-				throw bootstrapError;
-			}),
-			dispose: vi.fn(async () => undefined),
-		};
-		const adapter = {
-			start: vi.fn(async () => session),
-		};
-		const manifest = {
-			runtime: 'node',
-			appRootDir: '/repo',
-			sourceRootDir: '/repo/src',
-			distDir: '/repo/dist',
-			workDir: '/repo/.eco',
-			modulePaths: {
-				config: '/repo/eco.config.ts',
-				entry: '/repo/app.ts',
-			},
-		};
-
-		await expect(
-			startThinHostRuntime({
-				adapter,
-				manifest,
-				workingDirectory: '/repo',
-				cliArgs: ['app.ts', '--dev'],
-				attachShutdownHandlers: false,
-			}),
-		).rejects.toThrow('bootstrap failed');
-
-		expect(adapter.start).toHaveBeenCalledWith({
-			manifest,
-			workingDirectory: '/repo',
-			cliArgs: ['app.ts', '--dev'],
-		});
-		expect(session.loadApp).toHaveBeenCalledTimes(1);
-		expect(session.dispose).toHaveBeenCalledTimes(1);
-	});
-});