@b9g/platform-node 0.1.13 → 0.1.14-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-node",
-  "version": "0.1.13",
+  "version": "0.1.14-beta.0",
   "description": "Node.js platform adapter for Shovel with hot reloading and ESBuild integration",
   "keywords": [
     "shovel",
@@ -14,7 +14,7 @@
     "@b9g/cache": "^0.2.0-beta.0",
     "@b9g/http-errors": "^0.2.0-beta.0",
     "@b9g/node-webworker": "^0.2.0-beta.1",
-    "@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 hot reloading, ESBuild integration, and optimized caching for Node.js 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 NodePlatformOptions extends PlatformConfig {
     /** Port for development server (default: 3000) */
     port?: number;
@@ -19,6 +19,51 @@ export interface NodePlatformOptions extends PlatformConfig {
     /** Shovel configuration (caches, directories, etc.) */
     config?: ShovelConfig;
 }
+/**
+ * Node.js ServiceWorkerContainer implementation
+ * Manages ServiceWorker registrations backed by worker threads
+ */
+export declare class NodeServiceWorkerContainer 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: NodePlatform);
+    /**
+     * Register a ServiceWorker script
+     * Spawns worker threads and runs lifecycle
+     */
+    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>;
+}
 /**
  * Node.js platform implementation
  * ServiceWorker entrypoint loader for Node.js with ESBuild VM system
@@ -26,7 +71,21 @@ export interface NodePlatformOptions extends PlatformConfig {
 export declare class NodePlatform extends BasePlatform {
     #private;
     readonly name: string;
+    readonly serviceWorker: NodeServiceWorkerContainer;
     constructor(options?: NodePlatformOptions);
+    /**
+     * Create a worker instance for the pool
+     * Can be overridden for testing
+     */
+    createWorker(entrypoint: string): Promise<Worker>;
+    /**
+     * Start the HTTP server, routing requests to ServiceWorker
+     */
+    listen(): Promise<Server>;
+    /**
+     * Close the server and terminate workers
+     */
+    close(): Promise<void>;
     /**
      * Get options for testing
      */
@@ -38,33 +97,35 @@ export declare class NodePlatform extends BasePlatform {
         config?: ShovelConfig;
     };
     /**
-     * Get/set worker pool for testing
-     */
-    get workerPool(): ServiceWorkerPool | undefined;
-    set workerPool(pool: ServiceWorkerPool | undefined);
-    /**
-     * THE MAIN JOB - Load and run a ServiceWorker-style entrypoint in Node.js
-     * Uses Worker threads with coordinated cache storage for isolation and standards compliance
-     */
-    loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
-    /**
-     * Create cache storage using config from shovel.json
-     * Used for testing - production uses the generated config module
-     * Merges with runtime defaults (actual class references) for fallback behavior
+     * Create cache storage for Node.js
+     *
+     * 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
-     * Used for testing - production uses the generated config module
-     * Merges with runtime defaults (actual class references) for fallback behavior
+     * Create directory storage for Node.js
+     *
+     * 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 Node.js
+     *
+     * Uses LogTape for structured logging.
      */
     createLoggers(): Promise<CustomLoggerStorage>;
     /**
-     * Create database storage from declarative config in shovel.json
+     * Create database storage for Node.js
+     *
+     * Returns undefined if no databases configured in shovel.json.
+     * Supports SQLite via better-sqlite3.
      */
     createDatabases(configOverride?: NodePlatformOptions["config"]): CustomDatabaseStorage | undefined;
     /**
@@ -73,21 +134,18 @@ export declare class NodePlatform extends BasePlatform {
     createServer(handler: Handler, options?: ServerOptions): Server;
     /**
      * Reload workers for hot reloading (called by CLI)
+     * @deprecated Use serviceWorker.reloadWorkers() instead
      * @param entrypoint - Path to the new entrypoint (hashed filename)
      */
     reloadWorkers(entrypoint: string): Promise<void>;
     /**
-     * Get virtual entry wrapper for Node.js
-     *
-     * @param entryPath - Absolute path to user's entrypoint file
-     * @param options - Entry wrapper options
-     * @param options.type - "production" (default) or "worker"
+     * Get production entry points for bundling.
      *
-     * Returns:
-     * - "production": Server entry that loads ServiceWorkerPool
-     * - "worker": Worker entry that sets up runtime and message loop
+     * Node.js produces two files:
+     * - index.js: Supervisor that spawns workers and owns the HTTP server
+     * - worker.js: Worker that handles requests via message loop
      */
-    getEntryWrapper(entryPath: string, options?: EntryWrapperOptions): string;
+    getProductionEntryPoints(userEntryPath: string): ProductionEntryPoints;
     /**
      * Get Node.js-specific esbuild configuration
      *

package/src/index.js

@@ -1,220 +1,151 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
+import * as HTTP from "node:http";
 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 * as HTTP from "http";
-import * as Path from "path";
-import { getLogger } from "@logtape/logtape";
 import { MemoryCache as MemoryCache2 } from "@b9g/cache/memory";
-var entryTemplate = `// Node.js Production Server Entry
-import {tmpdir} from "os"; // For [tmpdir] config expressions
-import * as HTTP from "http";
-import {parentPort} from "worker_threads";
-import {Worker} from "@b9g/node-webworker";
-import {getLogger} from "@logtape/logtape";
-import {configureLogging} from "@b9g/platform/runtime";
-import {config} from "shovel:config"; // Virtual module - resolved at build time
-import Platform from "@b9g/platform-node";
-
-// 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 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 (WORKERS === 1) {
-	// Single worker mode: worker owns server (same as Bun)
-	// No reusePort needed since there's only one listener
-	if (isShovelWorker) {
-		// Worker thread: runs BOTH server AND ServiceWorker
-		const platform = new Platform({port: PORT, host: HOST, workers: 1});
-
-		// Track resources for shutdown - these get assigned during startup
-		let server;
-		let serviceWorker;
-
-		// Register shutdown handler BEFORE async startup to prevent race condition
-		// where SIGINT arrives during startup and the shutdown message is dropped
-		self.onmessage = async (event) => {
-			if (event.data.type === "shutdown") {
-				logger.info("Worker shutting down");
-				if (server) await server.close();
-				if (serviceWorker) await serviceWorker.dispose();
-				await platform.dispose();
-				postMessage({type: "shutdown-complete"});
-			}
-		};
-
-		const userCodePath = new URL("./server.js", import.meta.url).pathname;
-		serviceWorker = await platform.loadServiceWorker(userCodePath);
-
-		server = platform.createServer(serviceWorker.handleRequest, {
-			port: PORT,
-			host: HOST,
-		});
-		await server.listen();
-
-		// Signal ready to main thread
-		postMessage({type: "ready"});
-		logger.info("Worker started with server", {port: PORT});
-	} else {
-		// Main thread: supervisor only - spawn single worker
-		logger.info("Starting production server (single worker)", {port: PORT});
-
-		// Port availability check - fail fast if port is in use
-		const checkPort = () => new Promise((resolve, reject) => {
-			const testServer = HTTP.createServer();
-			testServer.once("error", reject);
-			testServer.listen(PORT, HOST, () => {
-				testServer.close(() => resolve(undefined));
-			});
-		});
-		try {
-			await checkPort();
-		} catch (err) {
-			logger.error("Port unavailable", {port: PORT, host: HOST, error: err});
-			process.exit(1);
-		}
-
-		let shuttingDown = false;
-
-		const worker = new Worker(new URL(import.meta.url), {
-			env: {SHOVEL_SPAWNED_WORKER: "1"},
-		});
-
-		worker.onmessage = (event) => {
-			if (event.data.type === "ready") {
-				logger.info("Worker ready", {port: PORT});
-			} else if (event.data.type === "shutdown-complete") {
-				logger.info("Worker shutdown complete");
-				process.exit(0);
-			}
-		};
-
-		worker.onerror = (event) => {
-			logger.error("Worker error", {error: event.error});
-		};
-
-		// If a worker crashes, fail fast - let process supervisor handle restarts
-		worker.addEventListener("close", (event) => {
-			if (shuttingDown) return;
-			if (event.code === 0) return; // Clean exit
-			logger.error("Worker crashed", {exitCode: event.code});
-			process.exit(1);
-		});
-
-		// Graceful shutdown
-		const shutdown = () => {
-			shuttingDown = true;
-			logger.info("Shutting down");
-			worker.postMessage({type: "shutdown"});
-		};
-
-		process.on("SIGINT", shutdown);
-		process.on("SIGTERM", shutdown);
-	}
-} else {
-	// Multi-worker mode: main thread owns server (no reusePort in Node.js)
-	// Workers handle ServiceWorker code via postMessage
-	if (isShovelWorker) {
-		// Worker: ServiceWorker only, respond via message loop
-		// This path uses the workerEntryTemplate, not this template
-		throw new Error("Multi-worker mode uses workerEntryTemplate, not entryTemplate");
-	} else {
-		// Main thread: HTTP server + dispatch to worker pool
-		const platform = new Platform({port: PORT, host: HOST, workers: WORKERS});
-		const userCodePath = new URL("./server.js", import.meta.url).pathname;
-
-		logger.info("Starting production server (multi-worker)", {workers: WORKERS, port: PORT});
-
-		// Load ServiceWorker with worker pool
-		const serviceWorker = await platform.loadServiceWorker(userCodePath, {
-			workerCount: WORKERS,
-		});
-
-		// Create HTTP server
-		const server = platform.createServer(serviceWorker.handleRequest, {
-			port: PORT,
-			host: HOST,
-		});
-
-		await server.listen();
-		logger.info("Server running", {url: \`http://\${HOST}:\${PORT}\`, workers: WORKERS});
-
-		// Graceful shutdown
-		const shutdown = async () => {
-			logger.info("Shutting down server");
-			await serviceWorker.dispose();
-			await platform.dispose();
-			await server.close();
-			logger.info("Server stopped");
-			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 for graceful shutdown (close connections before termination)
-startWorkerMessageLoop({registration, databases});
-`;
 var logger = getLogger(["shovel", "platform"]);
+var NodeServiceWorkerContainer = 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 worker threads and runs lifecycle
+   */
+  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) => this.#platform.createWorker(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 NodePlatform = class extends BasePlatform {
   name;
+  serviceWorker;
   #options;
-  #workerPool;
-  #singleThreadedRuntime;
-  #cacheStorage;
-  #directoryStorage;
   #databaseStorage;
+  #server;
   constructor(options = {}) {
     super(options);
     this.name = "node";
@@ -226,264 +157,93 @@ var NodePlatform = class extends BasePlatform {
       cwd,
       config: options.config
     };
+    this.serviceWorker = new NodeServiceWorkerContainer(this);
   }
   /**
-   * Get options for testing
+   * Create a worker instance for the pool
+   * Can be overridden for testing
    */
-  get options() {
-    return this.#options;
+  async createWorker(entrypoint) {
+    const { Worker: NodeWebWorker } = await import("@b9g/node-webworker");
+    return new NodeWebWorker(entrypoint);
   }
   /**
-   * Get/set worker pool for testing
+   * Start the HTTP server, routing requests to ServiceWorker
    */
-  get workerPool() {
-    return this.#workerPool;
-  }
-  set workerPool(pool) {
-    this.#workerPool = pool;
-  }
-  /**
-   * THE MAIN JOB - Load and run a ServiceWorker-style entrypoint in Node.js
-   * Uses Worker threads with coordinated cache storage for isolation and standards compliance
-   */
-  async loadServiceWorker(entrypoint, options = {}) {
-    const workerCount = options.workerCount ?? this.#options.workers;
-    if (workerCount === 1 && !options.hotReload) {
-      return this.#loadServiceWorkerDirect(entrypoint, options);
+  async listen() {
+    const pool = this.serviceWorker.pool;
+    if (!pool) {
+      throw new Error(
+        "No ServiceWorker registered. Call serviceWorker.register() first."
+      );
     }
-    return this.#loadServiceWorkerWithPool(entrypoint, options, workerCount);
+    this.#server = this.createServer((request) => pool.handleRequest(request));
+    await this.#server.listen();
+    return this.#server;
   }
   /**
-   * Load ServiceWorker directly in main thread (single-threaded mode)
-   * No postMessage overhead - maximum performance for production
+   * Close the server and terminate workers
    */
-  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 })
-      );
-    }
-    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))
-    });
-    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;
+  async close() {
+    await this.#server?.close();
+    await this.serviceWorker.terminate();
   }
   /**
-   * Load ServiceWorker using worker pool (multi-threaded mode or dev mode)
+   * Get options for testing
    */
-  async #loadServiceWorkerWithPool(entrypoint, _options, workerCount) {
-    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) {
-      this.#cacheStorage = new CustomCacheStorage(
-        createCacheFactory({
-          configs: config?.caches ?? {}
-        })
-      );
-    }
-    if (this.#singleThreadedRuntime) {
-      await this.#singleThreadedRuntime.terminate();
-      this.#singleThreadedRuntime = void 0;
-    }
-    if (this.#workerPool) {
-      await this.#workerPool.terminate();
-    }
-    logger.info("Creating ServiceWorker pool", {
-      entryPath,
-      workerCount
-    });
-    this.#workerPool = new ServiceWorkerPool(
-      {
-        workerCount,
-        requestTimeout: 3e4,
-        cwd: this.#options.cwd
-      },
-      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("ServiceWorkerPool not initialized");
-        }
-        return platform.#workerPool.handleRequest(request);
-      },
-      install: async () => {
-        logger.info("ServiceWorker installed", {
-          method: "worker_threads"
-        });
-      },
-      activate: async () => {
-        logger.info("ServiceWorker activated", {
-          method: "worker_threads"
-        });
-      },
-      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: ["worker_threads", "coordinated_caches"]
-    });
-    return instance;
+  get options() {
+    return this.#options;
   }
   /**
-   * Create cache storage using config from shovel.json
-   * Used for testing - production uses the generated config module
-   * Merges with runtime defaults (actual class references) for fallback behavior
+   * Create cache storage for Node.js
+   *
+   * 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
-   * Used for testing - production uses the generated config module
-   * Merges with runtime defaults (actual class references) for fallback behavior
+   * Create directory storage for Node.js
+   *
+   * 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 Node.js
+   *
+   * 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 Node.js
+   *
+   * Returns undefined if no databases configured in shovel.json.
+   * Supports SQLite via better-sqlite3.
    */
   createDatabases(configOverride) {
     const config = configOverride ?? this.#options.config;
@@ -584,31 +344,83 @@ var NodePlatform = class extends BasePlatform {
   }
   /**
    * Reload workers for hot reloading (called by CLI)
+   * @deprecated Use serviceWorker.reloadWorkers() instead
    * @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 Node.js
+   * 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"
-   *
-   * Returns:
-   * - "production": Server entry that loads ServiceWorkerPool
-   * - "worker": Worker entry that sets up runtime and message loop
+   * Node.js produces two files:
+   * - index.js: Supervisor that spawns workers and owns the HTTP server
+   * - worker.js: Worker that handles requests via message loop
    */
-  getEntryWrapper(entryPath, options) {
-    if (options?.type === "worker") {
-      return workerEntryTemplate.replace("__USER_ENTRY__", entryPath);
-    }
-    return entryTemplate;
+  getProductionEntryPoints(userEntryPath) {
+    const supervisorCode = `// Node.js Production Supervisor
+import {Worker} from "@b9g/node-webworker";
+import {getLogger} from "@logtape/logtape";
+import {configureLogging} from "@b9g/platform/runtime";
+import NodePlatform from "@b9g/platform-node";
+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
+// Override createWorker to use the imported Worker class (avoids require() issues with ESM)
+const platform = new NodePlatform({port: config.port, host: config.host, workers: config.workers});
+platform.createWorker = (entrypoint) => new Worker(entrypoint);
+await platform.serviceWorker.register(new URL("./worker.js", import.meta.url).href);
+await platform.serviceWorker.ready;
+
+// Start HTTP server
+await platform.listen();
+
+logger.info("Server started", {port: config.port, host: config.host, workers: config.workers});
+
+// Graceful shutdown
+const handleShutdown = async () => {
+	logger.info("Shutting down");
+	await platform.close();
+	process.exit(0);
+};
+process.on("SIGINT", handleShutdown);
+process.on("SIGTERM", handleShutdown);
+`;
+    const workerCode = `// Node.js Production Worker
+import {parentPort} from "node:worker_threads";
+import {configureLogging, initWorkerRuntime, runLifecycle, startWorkerMessageLoop} from "@b9g/platform/runtime";
+import {config} from "shovel:config";
+
+await configureLogging(config.logging);
+
+// Initialize worker runtime (installs ServiceWorker globals)
+const {registration, databases} = await initWorkerRuntime({config});
+
+// 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 message loop for request handling, or signal ready and exit in lifecycle-only mode
+if (config.lifecycle) {
+	parentPort?.postMessage({type: "ready"});
+	// Clean shutdown after lifecycle
+	if (databases) await databases.closeAll();
+	process.exit(0);
+} else {
+	startWorkerMessageLoop({registration, databases});
+}
+`;
+    return {
+      index: supervisorCode,
+      worker: workerCode
+    };
   }
   /**
    * Get Node.js-specific esbuild configuration
@@ -663,18 +475,8 @@ var NodePlatform = 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;
@@ -694,5 +496,6 @@ var src_default = NodePlatform;
 export {
   MemoryCache2 as DefaultCache,
   NodePlatform,
+  NodeServiceWorkerContainer,
   src_default as default
 };