@dangao/bun-server 2.2.0 → 3.0.0

package/src/prompt/stores/file-store.ts

@@ -6,6 +6,7 @@ import type {
 } from '../types';
 import { extractVariables } from '../types';
 import { InMemoryPromptStore } from './memory-store';
+import { getRuntime } from '../../platform/runtime';
 
 export interface FilePromptStoreConfig {
   /** Directory containing JSON prompt files (default: './.prompts') */
@@ -73,7 +74,7 @@ export class FilePromptStore implements PromptStore {
     if (deleted) {
       try {
         const path = `${this.promptsDir}/${id}.json`;
-        await Bun.file(path).exists() && Bun.write(path, ''); // Soft delete (empty file)
+        await getRuntime().fs.file(path).exists() && getRuntime().fs.write(path, ''); // Soft delete (empty file)
       } catch (_error) {
         // ignore
       }
@@ -86,12 +87,12 @@ export class FilePromptStore implements PromptStore {
     this.loaded = true;
 
     try {
-      const glob = new Bun.Glob('*.json');
-      const files = Array.from(glob.scanSync(this.promptsDir));
+      const runtime = getRuntime();
+      const files = runtime.fs.glob('*.json', this.promptsDir);
 
       for (const file of files) {
         try {
-          const content = await Bun.file(`${this.promptsDir}/${file}`).text();
+          const content = await runtime.fs.file(`${this.promptsDir}/${file}`).text();
           if (!content.trim()) continue;
 
           const data = JSON.parse(content) as {
@@ -127,7 +128,7 @@ export class FilePromptStore implements PromptStore {
         null,
         2,
       );
-      await Bun.write(`${this.promptsDir}/${template.id}.json`, content);
+      await getRuntime().fs.write(`${this.promptsDir}/${template.id}.json`, content);
     } catch (_error) {
       // Ignore write errors (e.g., read-only filesystem)
     }

package/src/rag/service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '../di/decorators';
 import { Inject } from '../di/decorators';
+import { getRuntime } from '../platform/runtime';
 import type { EmbeddingService } from '../embedding/service';
 import { EMBEDDING_SERVICE_TOKEN } from '../embedding/types';
 import type { VectorStore } from '../vector-store/types';
@@ -120,7 +121,7 @@ export class RagService {
         return source.content;
 
       case 'file': {
-        const file = Bun.file(source.path);
+        const file = getRuntime().fs.file(source.path);
         return file.text();
       }
 

package/src/request/response.ts

@@ -1,4 +1,7 @@
-import type { BodyInit, HeadersInit } from 'bun';
+import { getRuntime } from '../platform/runtime';
+
+/** Cross-runtime compatible headers input type */
+type HeadersInit = Headers | string[][] | Record<string, string>;
 
 /**
  * 响应封装类
@@ -131,17 +134,17 @@ export class ResponseBuilder {
     }
 
     if (typeof source === 'string') {
-      const file = Bun.file(source);
+      const file = getRuntime().fs.file(source);
       if (!headers.has('Content-Type') && file.type) {
         headers.set('Content-Type', file.type);
       }
-      return new Response(file, {
+      return new Response(file.stream(), {
         status: options.status ?? 200,
         headers,
       });
     }
 
-    return new Response(source as BodyInit, {
+    return new Response(source as any, {
       status: options.status ?? 200,
       headers,
     });

package/src/security/guards/execution-context.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import type { ServerWebSocket } from 'bun';
+import type { IWebSocket } from '../../platform/types';
 import type { Context } from '../../core/context';
 import type { ResponseBuilder } from '../../request/response';
 import type { Constructor } from '../../core/types';
@@ -38,14 +38,14 @@ class HttpArgumentsHostImpl implements HttpArgumentsHost {
  */
 class WsArgumentsHostImpl implements WsArgumentsHost {
   public constructor(
-    private readonly client: ServerWebSocket<unknown>,
+    private readonly client: IWebSocket<unknown>,
     private readonly data: unknown,
   ) {}
 
   /**
    * 获取 WebSocket 客户端
    */
-  public getClient(): ServerWebSocket<unknown> {
+  public getClient(): IWebSocket<unknown> {
     return this.client;
   }
 
@@ -80,7 +80,7 @@ export class ExecutionContextImpl implements ExecutionContext {
    * @param client - WebSocket 客户端
    * @param data - 消息数据
    */
-  public setWsContext(client: ServerWebSocket<unknown>, data: unknown): void {
+  public setWsContext(client: IWebSocket<unknown>, data: unknown): void {
     this.wsHost = new WsArgumentsHostImpl(client, data);
   }
 

package/src/security/guards/types.ts

@@ -1,7 +1,7 @@
 import type { Context } from '../../core/context';
 import type { ResponseBuilder } from '../../request/response';
 import type { Constructor } from '../../core/types';
-import type { ServerWebSocket } from 'bun';
+import type { IWebSocket } from '../../platform/types';
 
 /**
  * 守卫接口
@@ -43,7 +43,7 @@ export interface WsArgumentsHost {
    * 获取 WebSocket 客户端
    * @returns WebSocket 连接对象
    */
-  getClient(): ServerWebSocket<unknown>;
+  getClient(): IWebSocket<unknown>;
 
   /**
    * 获取消息数据

package/src/swagger/generator.ts

@@ -1,6 +1,7 @@
 import type { SwaggerDocument, SwaggerOptions, SwaggerPathItem } from './types';
 import { ControllerRegistry } from '../controller/controller';
 import { getControllerMetadata, getRouteMetadata } from '../controller/metadata';
+import { getRuntime } from '../platform/runtime';
 import {
   getApiTags,
   getApiOperation,
@@ -311,7 +312,7 @@ export class SwaggerGenerator {
    */
   public generateMarkdownHtml(): string {
     const md = this.generateMarkdown();
-    return Bun.markdown.html(md, { headings: true });
+    return getRuntime().parser.renderMarkdown(md);
   }
 
   /**

package/src/websocket/registry.ts

@@ -1,5 +1,4 @@
-import type { ServerWebSocket } from 'bun';
-
+import type { IWebSocket } from '../platform/types';
 import { Container } from '../di/container';
 import { ControllerRegistry } from '../controller/controller';
 import { getGatewayMetadata, getHandlerMetadata } from './decorators';
@@ -161,7 +160,7 @@ export class WebSocketGatewayRegistry {
    * @param args - 原始参数（message, code, reason 等，不包括 ws）
    */
   private async invokeHandler(
-    ws: ServerWebSocket<WebSocketConnectionData>,
+    ws: IWebSocket<WebSocketConnectionData>,
     definition: GatewayDefinition,
     handlerName: string | undefined,
     ...args: unknown[]
@@ -266,7 +265,7 @@ export class WebSocketGatewayRegistry {
     }
   }
 
-  public async handleOpen(ws: ServerWebSocket<WebSocketConnectionData>): Promise<void> {
+  public async handleOpen(ws: IWebSocket<WebSocketConnectionData>): Promise<void> {
     const path = ws.data?.path;
     const match = path ? this.getGateway(path) : undefined;
     if (!match) {
@@ -281,8 +280,8 @@ export class WebSocketGatewayRegistry {
   }
 
   public async handleMessage(
-    ws: ServerWebSocket<WebSocketConnectionData>,
-    message: string | ArrayBuffer | ArrayBufferView,
+    ws: IWebSocket<WebSocketConnectionData>,
+    message: string | ArrayBuffer | ArrayBufferView | Buffer,
   ): Promise<void> {
     const path = ws.data?.path;
     const match = path ? this.getGateway(path) : undefined;
@@ -298,7 +297,7 @@ export class WebSocketGatewayRegistry {
   }
 
   public async handleClose(
-    ws: ServerWebSocket<WebSocketConnectionData>,
+    ws: IWebSocket<WebSocketConnectionData>,
     code: number,
     reason: string,
   ): Promise<void> {

package/tests/controller/path-combination.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
 import { Application } from '../../src/core/application';
 import { Controller, ControllerRegistry } from '../../src/controller/controller';
-import { GET, POST } from '../../src/router/decorators';
-import { Param } from '../../src/controller/decorators';
+import { GET, POST, PUT, DELETE, PATCH } from '../../src/router/decorators';
+import { Param, Body } from '../../src/controller/decorators';
 import { RouteRegistry } from '../../src/router/registry';
 import { getTestPort } from '../utils/test-port';
 
@@ -203,6 +203,81 @@ describe('Controller Path Combination', () => {
     expect(rootResponse.status).toBe(404);
   });
 
+  test('should match GET POST PUT DELETE PATCH all registered on same dynamic route /api/:id independently', async () => {
+    @Controller('/api')
+    class ResourceController {
+      @GET('/:id')
+      public getResource(@Param('id') id: string) {
+        return { method: 'GET', id };
+      }
+
+      @POST('/:id')
+      public postResource(@Param('id') id: string) {
+        return { method: 'POST', id };
+      }
+
+      @PUT('/:id')
+      public putResource(@Param('id') id: string) {
+        return { method: 'PUT', id };
+      }
+
+      @DELETE('/:id')
+      public deleteResource(@Param('id') id: string) {
+        return { method: 'DELETE', id };
+      }
+
+      @PATCH('/:id')
+      public patchResource(@Param('id') id: string) {
+        return { method: 'PATCH', id };
+      }
+    }
+
+    app.registerController(ResourceController);
+    await app.listen();
+
+    const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] as const;
+    for (const method of methods) {
+      const res = await fetch(`http://localhost:${port}/api/123`, { method });
+      expect(res.status).toBe(200);
+      const data = await res.json() as { method: string; id: string };
+      expect(data.method).toBe(method);
+      expect(data.id).toBe('123');
+    }
+  });
+
+  test('should not cross-match methods: only registered methods respond 200, others respond 404/405', async () => {
+    @Controller('/items')
+    class ItemController {
+      @GET('/:id')
+      public getItem(@Param('id') id: string) {
+        return { method: 'GET', id };
+      }
+
+      @POST('/:id')
+      public createItem(@Param('id') id: string) {
+        return { method: 'POST', id };
+      }
+    }
+
+    app.registerController(ItemController);
+    await app.listen();
+
+    const getRes = await fetch(`http://localhost:${port}/items/42`);
+    expect(getRes.status).toBe(200);
+    expect((await getRes.json() as { method: string }).method).toBe('GET');
+
+    const postRes = await fetch(`http://localhost:${port}/items/42`, { method: 'POST' });
+    expect(postRes.status).toBe(200);
+    expect((await postRes.json() as { method: string }).method).toBe('POST');
+
+    // PUT and DELETE are not registered — should return a non-200 status
+    const putRes = await fetch(`http://localhost:${port}/items/42`, { method: 'PUT' });
+    expect(putRes.ok).toBe(false);
+
+    const deleteRes = await fetch(`http://localhost:${port}/items/42`, { method: 'DELETE' });
+    expect(deleteRes.ok).toBe(false);
+  });
+
   test('should correctly combine root controller "/" with method path "/health"', async () => {
     // 这是 metrics-rate-limit-app.ts 示例中的场景
     // @Controller('/') + @GET('/health') 应该映射到 /health，而不是 //health
@@ -275,6 +350,125 @@ describe('Controller Path Combination', () => {
     expect(dataResponse.status).toBe(200);
     expect((await dataResponse.json()).received).toBe(true);
   });
+
+  /**
+   * 模拟真实业务场景：ProjectController
+   *
+   * 路由表：
+   *   GET    /api/projects/         → list()
+   *   GET    /api/projects/:id      → get(id)
+   *   POST   /api/projects/         → create(dto)
+   *   PUT    /api/projects/:id      → update(id, dto)
+   *   DELETE /api/projects/:id      → remove(id)
+   *   GET    /api/projects/:id/pages → listPages(id)
+   */
+  test('ProjectController: all routes on /api/projects should match independently', async () => {
+    const db: Record<string, { id: string; name: string; description: string; pages: string[] }> = {
+      'proj-1': { id: 'proj-1', name: 'Alpha', description: 'desc-a', pages: ['page-1', 'page-2'] },
+      'proj-2': { id: 'proj-2', name: 'Beta',  description: 'desc-b', pages: [] },
+    };
+
+    @Controller('/api/projects')
+    class ProjectController {
+      @GET('/')
+      list() {
+        return Object.values(db);
+      }
+
+      @GET('/:id')
+      get(@Param('id') id: string) {
+        return db[id] ?? null;
+      }
+
+      @POST('/')
+      create(@Body() dto: { name: string; description?: string }) {
+        const id = `proj-new`;
+        db[id] = { id, name: dto.name, description: dto.description ?? '', pages: [] };
+        return db[id];
+      }
+
+      @PUT('/:id')
+      update(@Param('id') id: string, @Body() dto: { name?: string; description?: string }) {
+        if (!db[id]) return null;
+        db[id] = { ...db[id], ...dto };
+        return db[id];
+      }
+
+      @DELETE('/:id')
+      remove(@Param('id') id: string) {
+        const existed = !!db[id];
+        delete db[id];
+        return { success: existed };
+      }
+
+      @GET('/:id/pages')
+      listPages(@Param('id') id: string) {
+        return db[id]?.pages ?? [];
+      }
+    }
+
+    app.registerController(ProjectController);
+    await app.listen();
+
+    const base = `http://localhost:${port}/api/projects`;
+
+    // GET / → 列表
+    const listRes = await fetch(`${base}/`);
+    expect(listRes.status).toBe(200);
+    const list = await listRes.json() as { id: string }[];
+    expect(list.length).toBe(2);
+
+    // GET /:id → 单条
+    const getRes = await fetch(`${base}/proj-1`);
+    expect(getRes.status).toBe(200);
+    const item = await getRes.json() as { id: string; name: string };
+    expect(item.id).toBe('proj-1');
+    expect(item.name).toBe('Alpha');
+
+    // POST / → 创建
+    const createRes = await fetch(`${base}/`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Gamma', description: 'desc-c' }),
+    });
+    expect(createRes.status).toBe(200);
+    const created = await createRes.json() as { id: string; name: string };
+    expect(created.name).toBe('Gamma');
+
+    // PUT /:id → 更新
+    const updateRes = await fetch(`${base}/proj-1`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'Alpha-Updated' }),
+    });
+    expect(updateRes.status).toBe(200);
+    const updated = await updateRes.json() as { name: string };
+    expect(updated.name).toBe('Alpha-Updated');
+
+    // GET /:id/pages → 子资源，不能被 GET /:id 拦截
+    const pagesRes = await fetch(`${base}/proj-2/pages`);
+    expect(pagesRes.status).toBe(200);
+    const pages = await pagesRes.json() as string[];
+    expect(Array.isArray(pages)).toBe(true);
+
+    // proj-1 pages（改名后仍可访问）
+    const pages1Res = await fetch(`${base}/proj-1/pages`);
+    expect(pages1Res.status).toBe(200);
+    const pages1 = await pages1Res.json() as string[];
+    expect(pages1).toEqual(['page-1', 'page-2']);
+
+    // DELETE /:id → 删除
+    const delRes = await fetch(`${base}/proj-2`, { method: 'DELETE' });
+    expect(delRes.status).toBe(200);
+    const delData = await delRes.json() as { success: boolean };
+    expect(delData.success).toBe(true);
+
+    // 删除后 GET /:id 返回 null（项目已不存在）
+    const afterDelRes = await fetch(`${base}/proj-2`);
+    expect(afterDelRes.status).toBe(200);
+    const afterDel = await afterDelRes.json();
+    expect(afterDel).toBeNull();
+  });
 });
 
 /**

package/tests/files/static-middleware.test.ts

@@ -1,17 +1,20 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdtemp, rm } from 'node:fs/promises';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import { createStaticFileMiddleware } from '../../src/files/static-middleware';
 import { Context } from '../../src/core/context';
+import { initRuntime } from '../../src/platform/runtime';
+
+initRuntime('bun');
 
 describe('Static File Middleware', () => {
   let root: string;
 
   beforeEach(async () => {
     root = await mkdtemp(join(tmpdir(), 'bun-static-'));
-    await Bun.write(join(root, 'hello.txt'), 'hello world');
+    await writeFile(join(root, 'hello.txt'), 'hello world', 'utf-8');
   });
 
   afterEach(async () => {

package/tests/middleware/static-file.test.ts

@@ -1,14 +1,17 @@
 import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
-import { mkdir, rm } from 'fs/promises';
+import { mkdir, rm, writeFile as fsWriteFile } from 'fs/promises';
 import { join } from 'path';
 
 import { createStaticFileMiddleware } from '../../src/middleware/builtin/static-file';
 import { Context } from '../../src/core/context';
+import { initRuntime } from '../../src/platform/runtime';
+
+initRuntime('bun');
 
 const TMP_DIR = join(process.cwd(), 'tmp-static-test');
 
 async function writeFile(path: string, content: string): Promise<void> {
-  await Bun.write(path, content);
+  await fsWriteFile(path, content, 'utf-8');
 }
 
 describe('StaticFileMiddleware', () => {

package/tests/platform/bun/crypto.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runCryptoCases } from '../shared/crypto.cases';
+
+describe('BunCryptoAdapter', () => {
+  initRuntime('bun');
+  runCryptoCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().crypto);
+});

package/tests/platform/bun/database.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime } from '../../../src/platform/runtime';
+import { runDatabaseCases } from '../shared/database.cases';
+
+describe('BunDatabase', () => {
+  initRuntime('bun');
+  runDatabaseCases({ test, expect: expect as any, beforeEach: () => {} }, 'bun');
+});

package/tests/platform/bun/fs.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runFsCases } from '../shared/fs.cases';
+
+describe('BunFsAdapter', () => {
+  initRuntime('bun');
+  runFsCases({ test, expect: expect as any, beforeEach }, () => getRuntime().fs);
+});

package/tests/platform/bun/parser.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runParserCases } from '../shared/parser.cases';
+
+describe('BunParserAdapter', () => {
+  initRuntime('bun');
+  runParserCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().parser);
+});

package/tests/platform/bun/process.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runProcessCases } from '../shared/process.cases';
+
+describe('BunProcessAdapter', () => {
+  initRuntime('bun');
+  runProcessCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime().process);
+});

package/tests/platform/bun/websocket.test.ts

@@ -0,0 +1,8 @@
+import { describe, test, expect } from 'bun:test';
+import { initRuntime, getRuntime } from '../../../src/platform/runtime';
+import { runWebSocketCases } from '../shared/websocket.cases';
+
+describe('BunWebSocket', () => {
+  initRuntime('bun');
+  runWebSocketCases({ test, expect: expect as any, beforeEach: () => {} }, () => getRuntime());
+});

package/tests/platform/detector.test.ts

@@ -0,0 +1,57 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { resolvePlatform } from '../../src/platform/detector';
+
+describe('resolvePlatform priority chain', () => {
+  const originalArgv = process.argv.slice();
+  const originalEnv = process.env['BUN_SERVER_PLATFORM'];
+
+  afterEach(() => {
+    process.argv.length = 0;
+    for (const arg of originalArgv) process.argv.push(arg);
+    if (originalEnv === undefined) {
+      delete process.env['BUN_SERVER_PLATFORM'];
+    } else {
+      process.env['BUN_SERVER_PLATFORM'] = originalEnv;
+    }
+  });
+
+  test('bootstrap config takes highest priority over CLI arg', () => {
+    process.argv.push('--platform=node');
+    expect(resolvePlatform('bun')).toBe('bun');
+  });
+
+  test('CLI arg --platform=node', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    process.argv.push('--platform=node');
+    expect(resolvePlatform()).toBe('node');
+  });
+
+  test('CLI arg --platform=bun', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    process.argv.push('--platform=bun');
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('env var BUN_SERVER_PLATFORM=node', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'node';
+    expect(resolvePlatform()).toBe('node');
+  });
+
+  test('env var BUN_SERVER_PLATFORM=bun', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'bun';
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('CLI arg takes priority over env var', () => {
+    process.env['BUN_SERVER_PLATFORM'] = 'node';
+    process.argv.push('--platform=bun');
+    expect(resolvePlatform()).toBe('bun');
+  });
+
+  test('auto-detect returns bun when running in Bun', () => {
+    delete process.env['BUN_SERVER_PLATFORM'];
+    // We're running in Bun (bun:test), so auto-detect should return 'bun'
+    const result = resolvePlatform();
+    expect(result).toBe('bun');
+  });
+});

package/tests/platform/node/build-smoke.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, expect } from 'vitest';
+import { spawn } from 'node:child_process';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+/**
+ * 烟雾测试：验证 bun build --target=node 的输出能被 Node.js 原生运行
+ *
+ * 测试流程：
+ * 1. 创建最小化 app fixture
+ * 2. 使用 bun build --target=node 编译
+ * 3. 用 node 运行编译产物
+ * 4. 验证应用启动成功
+ */
+describe('Build Smoke Test (bun build --target=node)', () => {
+  test('compiled output runs on Node.js', async () => {
+    const tmpDir = join(tmpdir(), `build-smoke-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+
+    const outDir = join(tmpDir, 'out');
+    mkdirSync(outDir, { recursive: true });
+
+    // Create a minimal fixture app using the framework
+    const fixturePath = join(tmpDir, 'fixture.ts');
+    const pkgRoot = resolve(__dirname, '../../..');
+
+    writeFileSync(fixturePath, `
+import { Application } from '${pkgRoot}/src/index.ts';
+import { Module } from '${pkgRoot}/src/index.ts';
+
+@Module({})
+class AppModule {}
+
+const app = new Application({ platform: 'node' });
+app.registerModule(AppModule);
+app.listen(0).then(() => {
+  const server = app.getServer()?.getServer();
+  console.log('SMOKE_OK port=' + (server?.port ?? 0));
+  process.exit(0);
+}).catch((err) => {
+  console.error('SMOKE_FAIL', err.message);
+  process.exit(1);
+});
+`);
+
+    const outFile = join(outDir, 'app.cjs');
+
+    // Build with bun
+    const buildResult = await runCommand('bun', [
+      'build',
+      fixturePath,
+      '--target=node',
+      '--outfile=' + outFile,
+      '--format=cjs',
+    ]);
+
+    if (buildResult.exitCode !== 0) {
+      // Build may fail in CI without Bun; skip gracefully
+      console.warn('[build-smoke] bun build failed, skipping test:', buildResult.stderr);
+      return;
+    }
+
+    // Run compiled file with node
+    const nodeResult = await runCommand('node', [outFile], 5000);
+
+    try {
+      rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // ignore cleanup errors
+    }
+
+    expect(nodeResult.exitCode).toBe(0);
+    expect(nodeResult.stdout).toContain('SMOKE_OK');
+  }, 30000);
+});
+
+function runCommand(
+  cmd: string,
+  args: string[],
+  timeout = 15000,
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { timeout });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (d) => { stdout += d.toString(); });
+    child.stderr?.on('data', (d) => { stderr += d.toString(); });
+    child.on('close', (code) => resolve({ exitCode: code ?? 1, stdout, stderr }));
+    child.on('error', (err) => resolve({ exitCode: 1, stdout, stderr: err.message }));
+  });
+}