@b9g/platform-bun 0.1.11 → 0.1.12-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.11",
+  "version": "0.1.12-beta.0",
   "description": "Bun platform adapter for Shovel with hot reloading and built-in TypeScript/JSX support",
   "keywords": [
     "shovel",
@@ -15,7 +15,7 @@
     "@b9g/assets": "^0.2.0-beta.0",
     "@b9g/cache": "^0.2.0-beta.0",
     "@b9g/http-errors": "^0.2.0-beta.0",
-    "@b9g/platform": "^0.1.13",
+    "@b9g/platform": "^0.1.14-beta.0",
     "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {

package/src/index.d.ts

@@ -3,10 +3,10 @@
  *
  * Provides built-in TypeScript/JSX support and simplified server setup for Bun environments.
  */
-import { BasePlatform, type PlatformConfig, type PlatformDefaults, type Handler, type Server, type ServerOptions, type ServiceWorkerOptions, type ServiceWorkerInstance, type EntryWrapperOptions, type PlatformESBuildConfig, ServiceWorkerPool, CustomLoggerStorage, CustomDatabaseStorage } from "@b9g/platform";
-import { type ShovelConfig } from "@b9g/platform/runtime";
 import { CustomCacheStorage } from "@b9g/cache";
 import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { BasePlatform, type PlatformConfig, type PlatformDefaults, type Handler, type Server, type ServerOptions, type PlatformESBuildConfig, type ProductionEntryPoints, ServiceWorkerPool, CustomLoggerStorage, CustomDatabaseStorage } from "@b9g/platform";
+import { type ShovelConfig } from "@b9g/platform/runtime";
 export interface BunPlatformOptions extends PlatformConfig {
     /** Port for development server (default: 3000) */
     port?: number;
@@ -19,6 +19,55 @@ export interface BunPlatformOptions extends PlatformConfig {
     /** Shovel configuration (caches, directories, etc.) */
     config?: ShovelConfig;
 }
+/**
+ * Bun ServiceWorkerContainer implementation
+ * Manages ServiceWorker registrations backed by native Web Workers
+ *
+ * Note: In Bun's production model, workers handle their own HTTP servers
+ * via reusePort, so the supervisor doesn't route requests through the pool.
+ * This container is mainly for worker lifecycle management.
+ */
+export declare class BunServiceWorkerContainer extends EventTarget implements ServiceWorkerContainer {
+    #private;
+    readonly controller: ServiceWorker | null;
+    oncontrollerchange: ((ev: Event) => unknown) | null;
+    onmessage: ((ev: MessageEvent) => unknown) | null;
+    onmessageerror: ((ev: MessageEvent) => unknown) | null;
+    constructor(platform: BunPlatform);
+    /**
+     * Register a ServiceWorker script
+     * Spawns Web Workers (each with their own HTTP server in production)
+     */
+    register(scriptURL: string | URL, options?: RegistrationOptions): Promise<ServiceWorkerRegistration>;
+    /**
+     * Get registration for scope
+     */
+    getRegistration(scope?: string): Promise<ServiceWorkerRegistration | undefined>;
+    /**
+     * Get all registrations
+     */
+    getRegistrations(): Promise<readonly ServiceWorkerRegistration[]>;
+    /**
+     * Start receiving messages (no-op in server context)
+     */
+    startMessages(): void;
+    /**
+     * Ready promise - resolves when a registration is active
+     */
+    get ready(): Promise<ServiceWorkerRegistration>;
+    /**
+     * Internal: Get worker pool for request handling
+     */
+    get pool(): ServiceWorkerPool | undefined;
+    /**
+     * Internal: Terminate workers and dispose cache storage
+     */
+    terminate(): Promise<void>;
+    /**
+     * Internal: Reload workers (for hot reload)
+     */
+    reloadWorkers(entrypoint: string): Promise<void>;
+}
 /**
  * Bun platform implementation
  * ServiceWorker entrypoint loader for Bun with native TypeScript/JSX support
@@ -26,6 +75,7 @@ export interface BunPlatformOptions extends PlatformConfig {
 export declare class BunPlatform extends BasePlatform {
     #private;
     readonly name: string;
+    readonly serviceWorker: BunServiceWorkerContainer;
     constructor(options?: BunPlatformOptions);
     /**
      * Get options for testing
@@ -38,26 +88,35 @@ export declare class BunPlatform extends BasePlatform {
         config?: ShovelConfig;
     };
     /**
-     * Get/set worker pool for testing
-     */
-    get workerPool(): ServiceWorkerPool | undefined;
-    set workerPool(pool: ServiceWorkerPool | undefined);
-    /**
-     * Create cache storage using config from shovel.json
-     * Merges with runtime defaults (actual class references) for fallback behavior
+     * Create cache storage for Bun
+     *
+     * Default: MemoryCache (in-process LRU cache).
+     * Override via shovel.json caches config.
+     * Note: Used for dev/testing - production uses generated config module.
      */
     createCaches(): Promise<CustomCacheStorage>;
     /**
-     * Create directory storage using config from shovel.json
-     * Merges with runtime defaults (actual class references) for fallback behavior
+     * Create directory storage for Bun
+     *
+     * Defaults:
+     * - server: NodeFSDirectory at cwd (app files)
+     * - public: NodeFSDirectory at cwd (static assets)
+     * - tmp: NodeFSDirectory at OS temp dir
+     *
+     * Override via shovel.json directories config.
      */
     createDirectories(): Promise<CustomDirectoryStorage>;
     /**
-     * Create logger storage using config from shovel.json
+     * Create logger storage for Bun
+     *
+     * Uses LogTape for structured logging.
      */
     createLoggers(): Promise<CustomLoggerStorage>;
     /**
-     * Create database storage from declarative config in shovel.json
+     * Create database storage for Bun
+     *
+     * Returns undefined if no databases configured in shovel.json.
+     * Supports SQLite via bun:sqlite.
      */
     createDatabases(configOverride?: BunPlatformOptions["config"]): CustomDatabaseStorage | undefined;
     /**
@@ -65,28 +124,29 @@ export declare class BunPlatform extends BasePlatform {
      */
     createServer(handler: Handler, options?: ServerOptions): Server;
     /**
-     * Load and run a ServiceWorker-style entrypoint with Bun
-     * Uses native Web Workers with the common WorkerPool
+     * Start listening for connections using pool's handlers
+     */
+    listen(): Promise<Server>;
+    /**
+     * Close the server
      */
-    loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
+    close(): Promise<void>;
     /**
      * Reload workers for hot reloading (called by CLI)
      * @param entrypoint - Path to the new entrypoint (hashed filename)
      */
     reloadWorkers(entrypoint: string): Promise<void>;
     /**
-     * Get virtual entry wrapper for Bun
+     * Get production entry points for bundling.
      *
-     * @param entryPath - Absolute path to user's entrypoint file
-     * @param options - Entry wrapper options
-     * @param options.type - "production" (default) or "worker"
-     * @param options.outDir - Output directory (required for "worker" type)
+     * Bun produces two files:
+     * - index.js: Supervisor that spawns workers and handles signals
+     * - worker.js: Worker with its own HTTP server (uses reusePort for multi-worker)
      *
-     * Returns:
-     * - "production": Server entry with Bun.serve and reusePort
-     * - "worker": Worker entry that sets up runtime and message loop
+     * Unlike Node.js, Bun workers each bind their own server with reusePort,
+     * allowing the OS to load-balance across workers without message passing overhead.
      */
-    getEntryWrapper(entryPath: string, options?: EntryWrapperOptions): string;
+    getProductionEntryPoints(userEntryPath: string): ProductionEntryPoints;
     /**
      * Get Bun-specific esbuild configuration
      *

package/src/index.js

@@ -2,162 +2,148 @@
 // src/index.ts
 import { builtinModules } from "node:module";
 import { tmpdir } from "node:os";
+import * as Path from "node:path";
+import { getLogger } from "@logtape/logtape";
+import { CustomCacheStorage } from "@b9g/cache";
+import { MemoryCache } from "@b9g/cache/memory";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { NodeFSDirectory } from "@b9g/filesystem/node-fs";
+import { InternalServerError, isHTTPError } from "@b9g/http-errors";
 import {
   BasePlatform,
   ServiceWorkerPool,
-  SingleThreadedRuntime,
   CustomLoggerStorage,
   CustomDatabaseStorage,
-  createDatabaseFactory
+  createDatabaseFactory,
+  mergeConfigWithDefaults
 } from "@b9g/platform";
 import {
+  ShovelServiceWorkerRegistration,
+  kServiceWorker,
   createCacheFactory,
   createDirectoryFactory
 } from "@b9g/platform/runtime";
-import { CustomCacheStorage } from "@b9g/cache";
-import { MemoryCache } from "@b9g/cache/memory";
-import { CustomDirectoryStorage } from "@b9g/filesystem";
-import { NodeFSDirectory } from "@b9g/filesystem/node-fs";
-import { InternalServerError, isHTTPError } from "@b9g/http-errors";
-import { getLogger } from "@logtape/logtape";
-import * as Path from "path";
 import { MemoryCache as MemoryCache2 } from "@b9g/cache/memory";
-var entryTemplate = `// Bun Production Server Entry
-import {tmpdir} from "os"; // For [tmpdir] config expressions
-import {getLogger} from "@logtape/logtape";
-import {configureLogging} from "@b9g/platform/runtime";
-import {config} from "shovel:config"; // Virtual module - resolved at build time
-import BunPlatform from "@b9g/platform-bun";
-
-// Configure logging before anything else
-await configureLogging(config.logging);
-
-const logger = getLogger(["shovel", "platform"]);
-
-// Configuration from shovel:config
-const PORT = config.port;
-const HOST = config.host;
-const WORKERS = config.workers;
-
-// Use explicit marker instead of Bun.isMainThread
-// This handles the edge case where Shovel's build output is embedded in another worker
-const isShovelWorker = process.env.SHOVEL_SPAWNED_WORKER === "1";
-
-if (isShovelWorker) {
-	// Worker thread: runs BOTH server AND ServiceWorker
-	const platform = new BunPlatform({port: PORT, host: HOST, workers: 1});
-	const userCodePath = new URL("./server.js", import.meta.url).pathname;
-	const serviceWorker = await platform.loadServiceWorker(userCodePath);
-
-	Bun.serve({
-		port: PORT,
-		hostname: HOST,
-		// Only need reusePort for multi-worker (multiple listeners on same port)
-		reusePort: WORKERS > 1,
-		fetch: serviceWorker.handleRequest,
-	});
-
-	// Signal ready to main thread
-	postMessage({type: "ready", thread: Bun.threadId});
-	logger.info("Worker started", {port: PORT, thread: Bun.threadId});
-} else {
-	// Main thread: supervisor only - ALWAYS spawn workers (even for workers:1)
-	// This ensures ServiceWorker code always runs in a worker thread for dev/prod parity
-
-	// Port availability check - fail fast if port is in use
-	// Prevents accidental port sharing with other processes
-	const checkPort = async () => {
-		try {
-			const testServer = Bun.serve({port: PORT, hostname: HOST, fetch: () => new Response()});
-			testServer.stop();
-		} catch (err) {
-			logger.error("Port unavailable", {port: PORT, host: HOST, error: err});
-			process.exit(1);
-		}
-	};
-	await checkPort();
-
-	let shuttingDown = false;
-	const workers = [];
-	let readyCount = 0;
-
-	for (let i = 0; i < WORKERS; i++) {
-		const worker = new Worker(import.meta.path, {
-			env: {...process.env, SHOVEL_SPAWNED_WORKER: "1"},
-		});
-
-		worker.onmessage = (event) => {
-			if (event.data.type === "ready") {
-				readyCount++;
-				if (readyCount === WORKERS) {
-					logger.info("All workers ready", {count: WORKERS, port: PORT});
-				}
-			}
-		};
-
-		worker.onerror = (error) => {
-			logger.error("Worker error", {error: error.message});
-		};
-
-		// If a worker crashes, fail fast - let process supervisor handle restarts
-		worker.addEventListener("close", () => {
-			if (shuttingDown) return;
-			logger.error("Worker crashed, exiting");
-			process.exit(1);
-		});
-
-		workers.push(worker);
-	}
-
-	logger.info("Spawned workers", {count: WORKERS, port: PORT});
-
-	// Graceful shutdown
-	const shutdown = async () => {
-		shuttingDown = true;
-		logger.info("Shutting down workers");
-		for (const worker of workers) {
-			worker.terminate();
-		}
-		process.exit(0);
-	};
-
-	process.on("SIGINT", shutdown);
-	process.on("SIGTERM", shutdown);
-}
-`;
-var workerEntryTemplate = `// Worker Entry for ServiceWorkerPool
-// This file sets up the ServiceWorker runtime and message loop
-import {tmpdir} from "os"; // For [tmpdir] config expressions
-import {config} from "shovel:config";
-import {initWorkerRuntime, startWorkerMessageLoop, configureLogging} from "@b9g/platform/runtime";
-
-// Configure logging before anything else
-await configureLogging(config.logging);
-
-// Initialize the worker runtime (installs ServiceWorker globals)
-// Platform defaults and paths are already resolved at build time
-const {registration, databases} = await initWorkerRuntime({config});
-
-// Import user code (registers event handlers via addEventListener)
-// Must use dynamic import to ensure globals are installed first
-await import("__USER_ENTRY__");
-
-// Run ServiceWorker lifecycle
-await registration.install();
-await registration.activate();
-
-// Start the message loop (handles request/response messages from main thread)
-// Pass databases so they can be closed on graceful shutdown
-startWorkerMessageLoop({registration, databases});
-`;
 var logger = getLogger(["shovel", "platform"]);
+var BunServiceWorkerContainer = class extends EventTarget {
+  #platform;
+  #pool;
+  #cacheStorage;
+  #registration;
+  #readyPromise;
+  #readyResolve;
+  // Standard ServiceWorkerContainer properties
+  controller;
+  oncontrollerchange;
+  onmessage;
+  onmessageerror;
+  constructor(platform) {
+    super();
+    this.#platform = platform;
+    this.#readyPromise = new Promise((resolve2) => {
+      this.#readyResolve = resolve2;
+    });
+    this.controller = null;
+    this.oncontrollerchange = null;
+    this.onmessage = null;
+    this.onmessageerror = null;
+  }
+  /**
+   * Register a ServiceWorker script
+   * Spawns Web Workers (each with their own HTTP server in production)
+   */
+  async register(scriptURL, options) {
+    const urlStr = typeof scriptURL === "string" ? scriptURL : scriptURL.toString();
+    const scope = options?.scope ?? "/";
+    let entryPath;
+    if (urlStr.startsWith("file://")) {
+      entryPath = new URL(urlStr).pathname;
+    } else {
+      entryPath = Path.resolve(this.#platform.options.cwd, urlStr);
+    }
+    let config = this.#platform.options.config;
+    const configPath = Path.join(Path.dirname(entryPath), "config.js");
+    try {
+      const configModule = await import(configPath);
+      config = configModule.config ?? config;
+    } catch (error) {
+      logger.debug`Using platform config (no config.js found): ${error}`;
+    }
+    if (!this.#cacheStorage && config?.caches) {
+      this.#cacheStorage = new CustomCacheStorage(
+        createCacheFactory({ configs: config.caches })
+      );
+    }
+    if (this.#pool) {
+      await this.#pool.terminate();
+    }
+    this.#pool = new ServiceWorkerPool(
+      {
+        workerCount: this.#platform.options.workers,
+        createWorker: (entrypoint) => new Worker(entrypoint)
+      },
+      entryPath,
+      this.#cacheStorage
+    );
+    await this.#pool.init();
+    this.#registration = new ShovelServiceWorkerRegistration(scope, urlStr);
+    this.#registration[kServiceWorker]._setState("activated");
+    this.#readyResolve?.(this.#registration);
+    return this.#registration;
+  }
+  /**
+   * Get registration for scope
+   */
+  async getRegistration(scope) {
+    if (scope === void 0 || scope === "/" || scope === this.#registration?.scope) {
+      return this.#registration;
+    }
+    return void 0;
+  }
+  /**
+   * Get all registrations
+   */
+  async getRegistrations() {
+    return this.#registration ? [this.#registration] : [];
+  }
+  /**
+   * Start receiving messages (no-op in server context)
+   */
+  startMessages() {
+  }
+  /**
+   * Ready promise - resolves when a registration is active
+   */
+  get ready() {
+    return this.#readyPromise;
+  }
+  /**
+   * Internal: Get worker pool for request handling
+   */
+  get pool() {
+    return this.#pool;
+  }
+  /**
+   * Internal: Terminate workers and dispose cache storage
+   */
+  async terminate() {
+    await this.#pool?.terminate();
+    this.#pool = void 0;
+    await this.#cacheStorage?.dispose();
+    this.#cacheStorage = void 0;
+  }
+  /**
+   * Internal: Reload workers (for hot reload)
+   */
+  async reloadWorkers(entrypoint) {
+    await this.#pool?.reloadWorkers(entrypoint);
+  }
+};
 var BunPlatform = class extends BasePlatform {
   name;
+  serviceWorker;
   #options;
-  #workerPool;
-  #singleThreadedRuntime;
-  #cacheStorage;
-  #directoryStorage;
+  #server;
   #databaseStorage;
   constructor(options = {}) {
     super(options);
@@ -170,6 +156,7 @@ var BunPlatform = class extends BasePlatform {
       cwd,
       config: options.config
     };
+    this.serviceWorker = new BunServiceWorkerContainer(this);
   }
   /**
    * Get options for testing
@@ -178,62 +165,55 @@ var BunPlatform = class extends BasePlatform {
     return this.#options;
   }
   /**
-   * Get/set worker pool for testing
-   */
-  get workerPool() {
-    return this.#workerPool;
-  }
-  set workerPool(pool) {
-    this.#workerPool = pool;
-  }
-  /**
-   * Create cache storage using config from shovel.json
-   * Merges with runtime defaults (actual class references) for fallback behavior
+   * Create cache storage for Bun
+   *
+   * Default: MemoryCache (in-process LRU cache).
+   * Override via shovel.json caches config.
+   * Note: Used for dev/testing - production uses generated config module.
    */
   async createCaches() {
-    const runtimeDefaults = {
-      default: { impl: MemoryCache }
-    };
-    const userCaches = this.#options.config?.caches ?? {};
-    const configs = {};
-    const allNames = /* @__PURE__ */ new Set([
-      ...Object.keys(runtimeDefaults),
-      ...Object.keys(userCaches)
-    ]);
-    for (const name of allNames) {
-      configs[name] = { ...runtimeDefaults[name], ...userCaches[name] };
-    }
+    const defaults = { default: { impl: MemoryCache } };
+    const configs = mergeConfigWithDefaults(
+      defaults,
+      this.#options.config?.caches
+    );
     return new CustomCacheStorage(createCacheFactory({ configs }));
   }
   /**
-   * Create directory storage using config from shovel.json
-   * Merges with runtime defaults (actual class references) for fallback behavior
+   * Create directory storage for Bun
+   *
+   * Defaults:
+   * - server: NodeFSDirectory at cwd (app files)
+   * - public: NodeFSDirectory at cwd (static assets)
+   * - tmp: NodeFSDirectory at OS temp dir
+   *
+   * Override via shovel.json directories config.
    */
   async createDirectories() {
-    const runtimeDefaults = {
+    const defaults = {
       server: { impl: NodeFSDirectory, path: this.#options.cwd },
       public: { impl: NodeFSDirectory, path: this.#options.cwd },
       tmp: { impl: NodeFSDirectory, path: tmpdir() }
     };
-    const userDirs = this.#options.config?.directories ?? {};
-    const configs = {};
-    const allNames = /* @__PURE__ */ new Set([
-      ...Object.keys(runtimeDefaults),
-      ...Object.keys(userDirs)
-    ]);
-    for (const name of allNames) {
-      configs[name] = { ...runtimeDefaults[name], ...userDirs[name] };
-    }
+    const configs = mergeConfigWithDefaults(
+      defaults,
+      this.#options.config?.directories
+    );
     return new CustomDirectoryStorage(createDirectoryFactory(configs));
   }
   /**
-   * Create logger storage using config from shovel.json
+   * Create logger storage for Bun
+   *
+   * Uses LogTape for structured logging.
    */
   async createLoggers() {
     return new CustomLoggerStorage((categories) => getLogger(categories));
   }
   /**
-   * Create database storage from declarative config in shovel.json
+   * Create database storage for Bun
+   *
+   * Returns undefined if no databases configured in shovel.json.
+   * Supports SQLite via bun:sqlite.
    */
   createDatabases(configOverride) {
     const config = configOverride ?? this.#options.config;
@@ -249,9 +229,11 @@ var BunPlatform = class extends BasePlatform {
   createServer(handler, options = {}) {
     const requestedPort = options.port ?? this.#options.port;
     const hostname = options.host ?? this.#options.host;
+    const reusePort = options.reusePort ?? false;
     const server = Bun.serve({
       port: requestedPort,
       hostname,
+      reusePort,
       async fetch(request) {
         try {
           return await handler(request);
@@ -284,207 +266,125 @@ var BunPlatform = class extends BasePlatform {
     };
   }
   /**
-   * Load and run a ServiceWorker-style entrypoint with Bun
-   * Uses native Web Workers with the common WorkerPool
+   * Start listening for connections using pool's handlers
    */
-  async loadServiceWorker(entrypoint, options = {}) {
-    const workerCount = options.workerCount ?? this.#options.workers;
-    if (workerCount === 1 && !options.hotReload) {
-      return this.#loadServiceWorkerDirect(entrypoint, options);
-    }
-    return this.#loadServiceWorkerWithPool(entrypoint, options, workerCount);
-  }
-  /**
-   * Load ServiceWorker directly in main thread (single-threaded mode)
-   * No postMessage overhead - maximum performance for production
-   */
-  async #loadServiceWorkerDirect(entrypoint, _options) {
-    const entryPath = Path.resolve(this.#options.cwd, entrypoint);
-    let config = this.#options.config;
-    const configPath = Path.join(Path.dirname(entryPath), "config.js");
-    try {
-      const configModule = await import(configPath);
-      config = configModule.config ?? config;
-    } catch (err) {
-      logger.debug`Using platform config (no config.js): ${err}`;
-    }
-    if (!this.#cacheStorage) {
-      const runtimeCacheDefaults = {
-        default: { impl: MemoryCache }
-      };
-      const userCaches = config?.caches ?? {};
-      const cacheConfigs = {};
-      const allCacheNames = /* @__PURE__ */ new Set([
-        ...Object.keys(runtimeCacheDefaults),
-        ...Object.keys(userCaches)
-      ]);
-      for (const name of allCacheNames) {
-        cacheConfigs[name] = {
-          ...runtimeCacheDefaults[name],
-          ...userCaches[name]
-        };
-      }
-      this.#cacheStorage = new CustomCacheStorage(
-        createCacheFactory({ configs: cacheConfigs })
+  async listen() {
+    const pool = this.serviceWorker.pool;
+    if (!pool) {
+      throw new Error(
+        "No ServiceWorker registered - call serviceWorker.register() first"
       );
     }
-    if (!this.#directoryStorage) {
-      const runtimeDirDefaults = {
-        server: { impl: NodeFSDirectory },
-        public: { impl: NodeFSDirectory },
-        tmp: { impl: NodeFSDirectory }
-      };
-      const userDirs = config?.directories ?? {};
-      const dirConfigs = {};
-      const allDirNames = /* @__PURE__ */ new Set([
-        ...Object.keys(runtimeDirDefaults),
-        ...Object.keys(userDirs)
-      ]);
-      for (const name of allDirNames) {
-        dirConfigs[name] = { ...runtimeDirDefaults[name], ...userDirs[name] };
-      }
-      this.#directoryStorage = new CustomDirectoryStorage(
-        createDirectoryFactory(dirConfigs)
-      );
-    }
-    if (!this.#databaseStorage) {
-      this.#databaseStorage = this.createDatabases(config);
-    }
-    if (this.#singleThreadedRuntime) {
-      await this.#singleThreadedRuntime.terminate();
-    }
-    if (this.#workerPool) {
-      await this.#workerPool.terminate();
-      this.#workerPool = void 0;
-    }
-    logger.info("Creating single-threaded ServiceWorker runtime", { entryPath });
-    this.#singleThreadedRuntime = new SingleThreadedRuntime({
-      caches: this.#cacheStorage,
-      directories: this.#directoryStorage,
-      databases: this.#databaseStorage,
-      loggers: new CustomLoggerStorage((cats) => getLogger(cats))
+    this.#server = this.createServer((request) => pool.handleRequest(request), {
+      port: this.#options.port,
+      host: this.#options.host
     });
-    await this.#singleThreadedRuntime.init();
-    await this.#singleThreadedRuntime.load(entryPath);
-    const runtime = this.#singleThreadedRuntime;
-    const platform = this;
-    const instance = {
-      runtime,
-      handleRequest: async (request) => {
-        if (!platform.#singleThreadedRuntime) {
-          throw new Error("SingleThreadedRuntime not initialized");
-        }
-        return platform.#singleThreadedRuntime.handleRequest(request);
-      },
-      install: async () => {
-        logger.info("ServiceWorker installed", { method: "single_threaded" });
-      },
-      activate: async () => {
-        logger.info("ServiceWorker activated", { method: "single_threaded" });
-      },
-      get ready() {
-        return runtime?.ready ?? false;
-      },
-      dispose: async () => {
-        if (platform.#singleThreadedRuntime) {
-          await platform.#singleThreadedRuntime.terminate();
-          platform.#singleThreadedRuntime = void 0;
-        }
-        logger.info("ServiceWorker disposed", {});
-      }
-    };
-    logger.info("ServiceWorker loaded", {
-      features: ["single_threaded", "no_postmessage_overhead"]
-    });
-    return instance;
+    await this.#server.listen();
+    return this.#server;
   }
   /**
-   * Load ServiceWorker using worker pool (multi-threaded mode or dev mode)
+   * Close the server
    */
-  async #loadServiceWorkerWithPool(entrypoint, _options, workerCount) {
-    const entryPath = Path.resolve(this.#options.cwd, entrypoint);
-    if (!this.#cacheStorage) {
-      this.#cacheStorage = await this.createCaches();
-    }
-    if (this.#singleThreadedRuntime) {
-      await this.#singleThreadedRuntime.terminate();
-      this.#singleThreadedRuntime = void 0;
-    }
-    if (this.#workerPool) {
-      await this.#workerPool.terminate();
-    }
-    const poolOptions = {
-      workerCount,
-      requestTimeout: 3e4,
-      cwd: this.#options.cwd
-    };
-    logger.info("Creating ServiceWorker pool", { entryPath, workerCount });
-    this.#workerPool = new ServiceWorkerPool(
-      poolOptions,
-      entryPath,
-      this.#cacheStorage
-    );
-    await this.#workerPool.init();
-    const workerPool = this.#workerPool;
-    const platform = this;
-    const instance = {
-      runtime: workerPool,
-      handleRequest: async (request) => {
-        if (!platform.#workerPool) {
-          throw new Error("WorkerPool not initialized");
-        }
-        return platform.#workerPool.handleRequest(request);
-      },
-      install: async () => {
-        logger.info("ServiceWorker installed", { method: "native_web_workers" });
-      },
-      activate: async () => {
-        logger.info("ServiceWorker activated", { method: "native_web_workers" });
-      },
-      get ready() {
-        return workerPool?.ready ?? false;
-      },
-      dispose: async () => {
-        if (platform.#workerPool) {
-          await platform.#workerPool.terminate();
-          platform.#workerPool = void 0;
-        }
-        logger.info("ServiceWorker disposed", {});
-      }
-    };
-    logger.info("ServiceWorker loaded", {
-      features: ["native_web_workers", "coordinated_caches"]
-    });
-    return instance;
+  async close() {
+    await this.#server?.close();
+    this.#server = void 0;
   }
   /**
    * Reload workers for hot reloading (called by CLI)
    * @param entrypoint - Path to the new entrypoint (hashed filename)
    */
   async reloadWorkers(entrypoint) {
-    if (this.#workerPool) {
-      await this.#workerPool.reloadWorkers(entrypoint);
-    } else if (this.#singleThreadedRuntime) {
-      await this.#singleThreadedRuntime.load(entrypoint);
-    }
+    await this.serviceWorker.reloadWorkers(entrypoint);
   }
   /**
-   * Get virtual entry wrapper for Bun
+   * Get production entry points for bundling.
    *
-   * @param entryPath - Absolute path to user's entrypoint file
-   * @param options - Entry wrapper options
-   * @param options.type - "production" (default) or "worker"
-   * @param options.outDir - Output directory (required for "worker" type)
+   * Bun produces two files:
+   * - index.js: Supervisor that spawns workers and handles signals
+   * - worker.js: Worker with its own HTTP server (uses reusePort for multi-worker)
    *
-   * Returns:
-   * - "production": Server entry with Bun.serve and reusePort
-   * - "worker": Worker entry that sets up runtime and message loop
+   * Unlike Node.js, Bun workers each bind their own server with reusePort,
+   * allowing the OS to load-balance across workers without message passing overhead.
    */
-  getEntryWrapper(entryPath, options) {
-    if (options?.type === "worker") {
-      return workerEntryTemplate.replace("__USER_ENTRY__", entryPath);
-    }
-    return entryTemplate;
+  getProductionEntryPoints(userEntryPath) {
+    const supervisorCode = `// Bun Production Supervisor
+import {getLogger} from "@logtape/logtape";
+import {configureLogging} from "@b9g/platform/runtime";
+import BunPlatform from "@b9g/platform-bun";
+import {config} from "shovel:config";
+
+await configureLogging(config.logging);
+const logger = getLogger(["shovel", "platform"]);
+
+logger.info("Starting production server", {port: config.port, workers: config.workers});
+
+// Initialize platform and register ServiceWorker (workers handle their own HTTP via reusePort)
+const platform = new BunPlatform({port: config.port, host: config.host, workers: config.workers});
+await platform.serviceWorker.register(new URL("./worker.js", import.meta.url).href);
+await platform.serviceWorker.ready;
+
+logger.info("All workers ready", {port: config.port, workers: config.workers});
+
+// Graceful shutdown
+const handleShutdown = async () => {
+	logger.info("Shutting down");
+	await platform.serviceWorker.terminate();
+	process.exit(0);
+};
+process.on("SIGINT", handleShutdown);
+process.on("SIGTERM", handleShutdown);
+`;
+    const workerCode = `// Bun Production Worker
+import BunPlatform from "@b9g/platform-bun";
+import {getLogger} from "@logtape/logtape";
+import {configureLogging, initWorkerRuntime, runLifecycle, dispatchRequest} from "@b9g/platform/runtime";
+import {config} from "shovel:config";
+
+await configureLogging(config.logging);
+const logger = getLogger(["shovel", "platform"]);
+
+// Track resources for shutdown
+let server;
+let databases;
+
+// Register shutdown handler before async startup
+self.onmessage = async (event) => {
+	if (event.data.type === "shutdown") {
+		logger.info("Worker shutting down");
+		if (server) await server.close();
+		if (databases) await databases.closeAll();
+		postMessage({type: "shutdown-complete"});
+	}
+};
+
+// Initialize worker runtime (installs ServiceWorker globals)
+const result = await initWorkerRuntime({config});
+const registration = result.registration;
+databases = result.databases;
+
+// Import user code (registers event handlers)
+await import("${userEntryPath}");
+
+// Run ServiceWorker lifecycle (stage from config.lifecycle if present)
+await runLifecycle(registration, config.lifecycle?.stage);
+
+// Start server (skip in lifecycle-only mode)
+if (!config.lifecycle) {
+	const platform = new BunPlatform({port: config.port, host: config.host});
+	server = platform.createServer(
+		(request) => dispatchRequest(registration, request),
+		{reusePort: config.workers > 1},
+	);
+	await server.listen();
+}
+
+postMessage({type: "ready"});
+logger.info("Worker started", {port: config.port});
+`;
+    return {
+      index: supervisorCode,
+      worker: workerCode
+    };
   }
   /**
    * Get Bun-specific esbuild configuration
@@ -535,18 +435,8 @@ var BunPlatform = class extends BasePlatform {
    * Dispose of platform resources
    */
   async dispose() {
-    if (this.#singleThreadedRuntime) {
-      await this.#singleThreadedRuntime.terminate();
-      this.#singleThreadedRuntime = void 0;
-    }
-    if (this.#workerPool) {
-      await this.#workerPool.terminate();
-      this.#workerPool = void 0;
-    }
-    if (this.#cacheStorage) {
-      await this.#cacheStorage.dispose();
-      this.#cacheStorage = void 0;
-    }
+    await this.close();
+    await this.serviceWorker.terminate();
     if (this.#databaseStorage) {
       await this.#databaseStorage.closeAll();
       this.#databaseStorage = void 0;
@@ -565,6 +455,7 @@ var BunPlatform = class extends BasePlatform {
 var src_default = BunPlatform;
 export {
   BunPlatform,
+  BunServiceWorkerContainer,
   MemoryCache2 as DefaultCache,
   src_default as default
 };