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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.10",
+  "version": "0.1.12-beta.0",
   "description": "Bun platform adapter for Shovel with hot reloading and built-in TypeScript/JSX support",
   "keywords": [
     "shovel",
@@ -12,15 +12,14 @@
     "jsx"
   ],
   "dependencies": {
-    "@b9g/assets": "^0.1.15",
-    "@b9g/cache": "^0.1.5",
-    "@b9g/http-errors": "^0.1.5",
-    "@b9g/platform": "^0.1.12",
+    "@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.14-beta.0",
     "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {
-    "@b9g/libuild": "^0.1.18",
-    "bun-types": "latest"
+    "@b9g/libuild": "^0.1.18"
   },
   "type": "module",
   "types": "src/index.d.ts",

package/src/index.d.ts

@@ -3,9 +3,10 @@
  *
  * Provides built-in TypeScript/JSX support and simplified server setup for Bun environments.
  */
-import { BasePlatform, type PlatformConfig, type Handler, type Server, type ServerOptions, type ServiceWorkerOptions, type ServiceWorkerInstance, type EntryWrapperOptions, type PlatformEsbuildConfig, ServiceWorkerPool } from "@b9g/platform";
 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;
@@ -15,6 +16,57 @@ export interface BunPlatformOptions extends PlatformConfig {
     cwd?: string;
     /** Number of worker threads (default: 1) */
     workers?: number;
+    /** 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
@@ -23,63 +75,107 @@ 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
      */
-    get options(): Required<BunPlatformOptions>;
+    get options(): {
+        port: number;
+        host: string;
+        cwd: string;
+        workers: number;
+        config?: ShovelConfig;
+    };
+    /**
+     * 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>;
     /**
-     * Get/set worker pool for testing
+     * 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.
      */
-    get workerPool(): ServiceWorkerPool | undefined;
-    set workerPool(pool: ServiceWorkerPool | undefined);
+    createDirectories(): Promise<CustomDirectoryStorage>;
     /**
-     * Create cache storage (in-memory by default)
+     * Create logger storage for Bun
+     *
+     * Uses LogTape for structured logging.
      */
-    createCaches(): Promise<CustomCacheStorage>;
+    createLoggers(): Promise<CustomLoggerStorage>;
     /**
-     * Create directory storage for the given base directory
+     * Create database storage for Bun
+     *
+     * Returns undefined if no databases configured in shovel.json.
+     * Supports SQLite via bun:sqlite.
      */
-    createDirectories(baseDir: string): CustomDirectoryStorage;
+    createDatabases(configOverride?: BunPlatformOptions["config"]): CustomDatabaseStorage | undefined;
     /**
      * Create HTTP server using Bun.serve
      */
     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.
      *
-     * Returns production server entry template that uses:
-     * - shovel:config virtual module for configuration
-     * - Bun.serve with reusePort for multi-worker scaling
-     * - Direct import of user's server code
+     * 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)
      *
-     * The template is a real .ts file (entry-template.ts) for better
-     * IDE support and linting. It's imported with {type: "text"}.
+     * 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
      *
      * Note: Bun natively supports import.meta.env, so no define alias is needed.
      * We use platform: "node" since Bun is Node-compatible for module resolution.
      */
-    getEsbuildConfig(): PlatformEsbuildConfig;
+    getESBuildConfig(): PlatformESBuildConfig;
+    /**
+     * Get Bun-specific defaults for config generation
+     *
+     * Provides default directories (server, public, tmp) that work
+     * out of the box for Bun deployments.
+     */
+    getDefaults(): PlatformDefaults;
     /**
      * Dispose of platform resources
      */
     dispose(): Promise<void>;
+    /**
+     * Get the OS temp directory (Bun-specific implementation using node:os)
+     */
+    tmpdir(): string;
 }
 /**
  * Default export for easy importing
  */
 export default BunPlatform;
+/**
+ * Platform's default cache implementation.
+ * Re-exported so config can reference: { module: "@b9g/platform-bun", export: "DefaultCache" }
+ */
+export { MemoryCache as DefaultCache } from "@b9g/cache/memory";

package/src/index.js

@@ -1,92 +1,150 @@
 /// <reference types="./index.d.ts" />
 // 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
+  CustomLoggerStorage,
+  CustomDatabaseStorage,
+  createDatabaseFactory,
+  mergeConfigWithDefaults
 } from "@b9g/platform";
-import { CustomCacheStorage } from "@b9g/cache";
-import { CustomDirectoryStorage } from "@b9g/filesystem";
-import { MemoryCache } from "@b9g/cache/memory";
-import { NodeDirectory } from "@b9g/filesystem/node";
-import { InternalServerError, isHTTPError } from "@b9g/http-errors";
-import { getLogger } from "@logtape/logtape";
-import * as Path from "path";
-var entryTemplate = `// Bun Production Server Entry
-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(["platform"]);
-
-// Configuration from shovel:config
-const PORT = config.port;
-const HOST = config.host;
-const WORKERS = config.workers;
-const isWorker = !Bun.isMainThread;
-
-// Worker thread entry - each worker runs its own Bun.serve with reusePort
-if (isWorker) {
-	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,
-		reusePort: true,
-		fetch: serviceWorker.handleRequest,
-	});
-
-	logger.info("Worker started", {port: PORT, thread: Bun.threadId});
-} else {
-	// Main thread - spawn worker threads, each binds to same port with reusePort
-	if (WORKERS > 1) {
-		for (let i = 0; i < WORKERS; i++) {
-			new Worker(import.meta.path);
-		}
-		logger.info("Spawned workers", {count: WORKERS, port: PORT});
-	} else {
-		// Single worker mode - run directly in main thread
-		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);
-
-		const server = platform.createServer(serviceWorker.handleRequest, {
-			port: PORT,
-			host: HOST,
-		});
-		await server.listen();
-
-		logger.info("Server started", {url: server.url});
-
-		// Graceful shutdown
-		const shutdown = async () => {
-			logger.info("Shutting down");
-			await serviceWorker.dispose();
-			await platform.dispose();
-			await server.close();
-			process.exit(0);
-		};
-
-		process.on("SIGINT", shutdown);
-		process.on("SIGTERM", shutdown);
-	}
-}
-`;
-var logger = getLogger(["platform"]);
+import {
+  ShovelServiceWorkerRegistration,
+  kServiceWorker,
+  createCacheFactory,
+  createDirectoryFactory
+} from "@b9g/platform/runtime";
+import { MemoryCache as MemoryCache2 } from "@b9g/cache/memory";
+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);
     this.name = "bun";
@@ -96,8 +154,9 @@ var BunPlatform = class extends BasePlatform {
       host: options.host ?? "localhost",
       workers: options.workers ?? 1,
       cwd,
-      ...options
+      config: options.config
     };
+    this.serviceWorker = new BunServiceWorkerContainer(this);
   }
   /**
    * Get options for testing
@@ -106,35 +165,63 @@ var BunPlatform = class extends BasePlatform {
     return this.#options;
   }
   /**
-   * Get/set worker pool for testing
+   * 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.
    */
-  get workerPool() {
-    return this.#workerPool;
+  async createCaches() {
+    const defaults = { default: { impl: MemoryCache } };
+    const configs = mergeConfigWithDefaults(
+      defaults,
+      this.#options.config?.caches
+    );
+    return new CustomCacheStorage(createCacheFactory({ configs }));
   }
-  set workerPool(pool) {
-    this.#workerPool = pool;
+  /**
+   * 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 defaults = {
+      server: { impl: NodeFSDirectory, path: this.#options.cwd },
+      public: { impl: NodeFSDirectory, path: this.#options.cwd },
+      tmp: { impl: NodeFSDirectory, path: tmpdir() }
+    };
+    const configs = mergeConfigWithDefaults(
+      defaults,
+      this.#options.config?.directories
+    );
+    return new CustomDirectoryStorage(createDirectoryFactory(configs));
   }
   /**
-   * Create cache storage (in-memory by default)
+   * Create logger storage for Bun
+   *
+   * Uses LogTape for structured logging.
    */
-  async createCaches() {
-    return new CustomCacheStorage((name) => new MemoryCache(name));
+  async createLoggers() {
+    return new CustomLoggerStorage((categories) => getLogger(categories));
   }
   /**
-   * Create directory storage for the given base directory
+   * Create database storage for Bun
+   *
+   * Returns undefined if no databases configured in shovel.json.
+   * Supports SQLite via bun:sqlite.
    */
-  createDirectories(baseDir) {
-    return new CustomDirectoryStorage((name) => {
-      let dirPath;
-      if (name === "static") {
-        dirPath = Path.resolve(baseDir, "../static");
-      } else if (name === "server") {
-        dirPath = baseDir;
-      } else {
-        dirPath = Path.resolve(baseDir, `../${name}`);
-      }
-      return Promise.resolve(new NodeDirectory(dirPath));
-    });
+  createDatabases(configOverride) {
+    const config = configOverride ?? this.#options.config;
+    if (config?.databases && Object.keys(config.databases).length > 0) {
+      const factory = createDatabaseFactory(config.databases);
+      return new CustomDatabaseStorage(factory);
+    }
+    return void 0;
   }
   /**
    * Create HTTP server using Bun.serve
@@ -142,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);
@@ -177,162 +266,125 @@ var BunPlatform = class extends BasePlatform {
     };
   }
   /**
-   * Load and run a ServiceWorker-style entrypoint with Bun
-   * Uses native Web Workers with the common WorkerPool
-   */
-  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
+   * Start listening for connections using pool's handlers
    */
-  async #loadServiceWorkerDirect(entrypoint, _options) {
-    const entryPath = Path.resolve(this.#options.cwd, entrypoint);
-    const entryDir = Path.dirname(entryPath);
-    if (!this.#cacheStorage) {
-      this.#cacheStorage = await this.createCaches();
-    }
-    if (!this.#directoryStorage) {
-      this.#directoryStorage = this.createDirectories(entryDir);
-    }
-    if (this.#singleThreadedRuntime) {
-      await this.#singleThreadedRuntime.terminate();
+  async listen() {
+    const pool = this.serviceWorker.pool;
+    if (!pool) {
+      throw new Error(
+        "No ServiceWorker registered - call serviceWorker.register() first"
+      );
     }
-    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,
-      loggers: new CustomLoggerStorage((...cats) => getLogger(cats))
-    });
-    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"]
+    this.#server = this.createServer((request) => pool.handleRequest(request), {
+      port: this.#options.port,
+      host: this.#options.host
     });
-    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,
-      {}
-      // Empty config - use defaults
-    );
-    await this.#workerPool.init();
-    await this.#workerPool.reloadWorkers(entryPath);
-    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.
    *
-   * Returns production server entry template that uses:
-   * - shovel:config virtual module for configuration
-   * - Bun.serve with reusePort for multi-worker scaling
-   * - Direct import of user's server code
+   * 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)
    *
-   * The template is a real .ts file (entry-template.ts) for better
-   * IDE support and linting. It's imported with {type: "text"}.
+   * 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) {
-    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
@@ -340,32 +392,70 @@ var BunPlatform = class extends BasePlatform {
    * Note: Bun natively supports import.meta.env, so no define alias is needed.
    * We use platform: "node" since Bun is Node-compatible for module resolution.
    */
-  getEsbuildConfig() {
+  getESBuildConfig() {
     return {
       platform: "node",
-      external: ["node:*"]
+      external: ["node:*", "bun", "bun:*", ...builtinModules]
+    };
+  }
+  /**
+   * Get Bun-specific defaults for config generation
+   *
+   * Provides default directories (server, public, tmp) that work
+   * out of the box for Bun deployments.
+   */
+  getDefaults() {
+    return {
+      caches: {
+        default: {
+          module: "@b9g/cache/memory",
+          export: "MemoryCache"
+        }
+      },
+      directories: {
+        server: {
+          module: "@b9g/filesystem/node-fs",
+          export: "NodeFSDirectory",
+          path: "[outdir]/server"
+        },
+        public: {
+          module: "@b9g/filesystem/node-fs",
+          export: "NodeFSDirectory",
+          path: "[outdir]/public"
+        },
+        tmp: {
+          module: "@b9g/filesystem/node-fs",
+          export: "NodeFSDirectory",
+          path: "[tmpdir]"
+        }
+      }
     };
   }
   /**
    * 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;
     }
   }
+  // =========================================================================
+  // Config Expression Method Overrides
+  // =========================================================================
+  /**
+   * Get the OS temp directory (Bun-specific implementation using node:os)
+   */
+  tmpdir() {
+    return tmpdir();
+  }
 };
 var src_default = BunPlatform;
 export {
   BunPlatform,
+  BunServiceWorkerContainer,
+  MemoryCache2 as DefaultCache,
   src_default as default
 };