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

package/README.md

@@ -8,7 +8,7 @@ Node.js platform adapter for Shovel. Runs ServiceWorker applications on Node.js
 - Hot module reloading for development via VM module system
 - Worker thread pool for concurrent request handling
 - Memory and filesystem cache backends
-- File System Access API implementation via NodeDirectory
+- File System Access API implementation via NodeFSDirectory
 - ServiceWorker lifecycle support (install, activate, fetch events)
 
 ## Installation
@@ -112,7 +112,7 @@ Loads and runs a ServiceWorker entrypoint.
 Configured via `caches` option:
 
 - `memory`: In-memory caching (MemoryCache)
-- `filesystem`: File-based caching (NodeDirectory)
+- `filesystem`: File-based caching (NodeFSDirectory)
 
 ## Worker Thread Architecture
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-node",
-  "version": "0.1.12",
+  "version": "0.1.14-beta.0",
   "description": "Node.js platform adapter for Shovel with hot reloading and ESBuild integration",
   "keywords": [
     "shovel",
@@ -11,14 +11,14 @@
     "esbuild"
   ],
   "dependencies": {
-    "@b9g/cache": "^0.1.5",
-    "@b9g/http-errors": "^0.1.5",
-    "@b9g/platform": "^0.1.12",
+    "@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.14-beta.0",
     "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {
     "@b9g/libuild": "^0.1.18",
-    "bun-types": "latest",
     "@types/node": "^18.0.0"
   },
   "type": "module",

package/src/index.d.ts

@@ -3,9 +3,10 @@
  *
  * Provides hot reloading, ESBuild integration, and optimized caching for Node.js 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 NodePlatformOptions extends PlatformConfig {
     /** Port for development server (default: 3000) */
     port?: number;
@@ -15,6 +16,53 @@ export interface NodePlatformOptions extends PlatformConfig {
     cwd?: string;
     /** Number of worker threads (default: 1) */
     workers?: number;
+    /** 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
@@ -23,63 +71,110 @@ export interface NodePlatformOptions extends PlatformConfig {
 export declare class NodePlatform extends BasePlatform {
     #private;
     readonly name: string;
+    readonly serviceWorker: NodeServiceWorkerContainer;
     constructor(options?: NodePlatformOptions);
     /**
-     * Get options for testing
+     * 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
      */
-    get options(): Required<NodePlatformOptions>;
+    listen(): Promise<Server>;
     /**
-     * Get/set worker pool for testing
+     * Close the server and terminate workers
      */
-    get workerPool(): ServiceWorkerPool | undefined;
-    set workerPool(pool: ServiceWorkerPool | undefined);
+    close(): Promise<void>;
     /**
-     * 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
+     * Get options for testing
      */
-    loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
+    get options(): {
+        port: number;
+        host: string;
+        cwd: string;
+        workers: number;
+        config?: ShovelConfig;
+    };
     /**
-     * Create cache storage (in-memory by default)
+     * 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 for the given base directory
+     * 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(baseDir: string): CustomDirectoryStorage;
+    createDirectories(): Promise<CustomDirectoryStorage>;
+    /**
+     * Create logger storage for Node.js
+     *
+     * Uses LogTape for structured logging.
+     */
+    createLoggers(): Promise<CustomLoggerStorage>;
+    /**
+     * 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;
     /**
      * SUPPORTING UTILITY - Create HTTP server for Node.js
      */
     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
-     *
-     * Returns production server entry template that uses:
-     * - shovel:config virtual module for configuration
-     * - Worker threads via ServiceWorkerPool for multi-worker scaling
-     * - Platform's loadServiceWorker and createServer methods
+     * Get production entry points for bundling.
      *
-     * The template is a real .ts file (entry-template.ts) for better
-     * IDE support and linting. It's imported with {type: "text"}.
+     * 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
      *
      * Note: Node.js doesn't support import.meta.env natively, so we alias it
      * to process.env for compatibility with code that uses Vite-style env access.
      */
-    getEsbuildConfig(): PlatformEsbuildConfig;
+    getESBuildConfig(): PlatformESBuildConfig;
+    /**
+     * Get Node.js-specific defaults for config generation
+     *
+     * Provides default directories (server, public, tmp) that work
+     * out of the box for Node.js deployments.
+     */
+    getDefaults(): PlatformDefaults;
     /**
      * Dispose of platform resources
      */
     dispose(): Promise<void>;
+    /**
+     * Get the OS temp directory (Node.js-specific implementation)
+     */
+    tmpdir(): string;
 }
 /**
  * Default export for easy importing
  */
 export default NodePlatform;
+/**
+ * Platform's default cache implementation.
+ * Re-exported so config can reference: { module: "@b9g/platform-node", export: "DefaultCache" }
+ */
+export { MemoryCache as DefaultCache } from "@b9g/cache/memory";

package/src/index.js

@@ -1,82 +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
+  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 * as HTTP from "http";
-import * as Path from "path";
-import { getLogger } from "@logtape/logtape";
-var entryTemplate = `// Node.js Production Server Entry
-// This file is imported as text and used as the entry wrapper template
-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(["platform"]);
-
-// Configuration from shovel:config (with process.env fallbacks baked in)
-const PORT = config.port;
-const HOST = config.host;
-const WORKER_COUNT = config.workers;
-
-logger.info("Starting production server", {});
-logger.info("Workers", {count: WORKER_COUNT});
-
-// Create platform instance
-const platform = new Platform();
-
-// Get the path to the user's ServiceWorker code
-const userCodeURL = new URL("./server.js", import.meta.url);
-const userCodePath = userCodeURL.pathname;
-
-// Load ServiceWorker with worker pool
-const serviceWorker = await platform.loadServiceWorker(userCodePath, {
-	workerCount: WORKER_COUNT,
-});
-
-// Create HTTP server
-const server = platform.createServer(serviceWorker.handleRequest, {
-	port: PORT,
-	host: HOST,
-});
-
-await server.listen();
-logger.info("Server running", {url: \`http://\${HOST}:\${PORT}\`});
-logger.info("Load balancing", {workers: WORKER_COUNT});
-
-// 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);
+import {
+  ShovelServiceWorkerRegistration,
+  kServiceWorker,
+  createCacheFactory,
+  createDirectoryFactory
+} from "@b9g/platform/runtime";
+import { MemoryCache as MemoryCache2 } from "@b9g/cache/memory";
+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);
+  }
 };
-
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
-`;
-var logger = getLogger(["platform"]);
 var NodePlatform = class extends BasePlatform {
   name;
+  serviceWorker;
   #options;
-  #workerPool;
-  #singleThreadedRuntime;
-  #cacheStorage;
-  #directoryStorage;
+  #databaseStorage;
+  #server;
   constructor(options = {}) {
     super(options);
     this.name = "node";
@@ -86,184 +155,103 @@ var NodePlatform = class extends BasePlatform {
       host: options.host ?? "localhost",
       workers: options.workers ?? 1,
       cwd,
-      ...options
+      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;
+  async listen() {
+    const pool = this.serviceWorker.pool;
+    if (!pool) {
+      throw new Error(
+        "No ServiceWorker registered. Call serviceWorker.register() first."
+      );
+    }
+    this.#server = this.createServer((request) => pool.handleRequest(request));
+    await this.#server.listen();
+    return this.#server;
   }
   /**
-   * 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
+   * Close the server and terminate workers
    */
-  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);
+  async close() {
+    await this.#server?.close();
+    await this.serviceWorker.terminate();
   }
   /**
-   * Load ServiceWorker directly in main thread (single-threaded mode)
-   * No postMessage overhead - maximum performance for production
+   * Get options for testing
    */
-  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();
-    }
-    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"]
-    });
-    return instance;
+  get options() {
+    return this.#options;
   }
   /**
-   * Load ServiceWorker using worker pool (multi-threaded mode or dev mode)
+   * 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 #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();
-    }
-    logger.info("Creating ServiceWorker pool", {
-      entryPath,
-      workerCount
-    });
-    this.#workerPool = new ServiceWorkerPool(
-      {
-        workerCount,
-        requestTimeout: 3e4,
-        cwd: this.#options.cwd
-      },
-      entryPath,
-      this.#cacheStorage,
-      {}
-      // Empty config - use defaults
+  async createCaches() {
+    const defaults = { default: { impl: MemoryCache } };
+    const configs = mergeConfigWithDefaults(
+      defaults,
+      this.#options.config?.caches
     );
-    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("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", {});
-      }
+    return new CustomCacheStorage(createCacheFactory({ configs }));
+  }
+  /**
+   * 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 defaults = {
+      server: { impl: NodeFSDirectory, path: this.#options.cwd },
+      public: { impl: NodeFSDirectory, path: this.#options.cwd },
+      tmp: { impl: NodeFSDirectory, path: tmpdir() }
     };
-    logger.info("ServiceWorker loaded", {
-      features: ["worker_threads", "coordinated_caches"]
-    });
-    return instance;
+    const configs = mergeConfigWithDefaults(
+      defaults,
+      this.#options.config?.directories
+    );
+    return new CustomDirectoryStorage(createDirectoryFactory(configs));
   }
   /**
-   * Create cache storage (in-memory by default)
+   * Create logger storage for Node.js
+   *
+   * 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 Node.js
+   *
+   * Returns undefined if no databases configured in shovel.json.
+   * Supports SQLite via better-sqlite3.
    */
-  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;
   }
   /**
    * SUPPORTING UTILITY - Create HTTP server for Node.js
@@ -356,28 +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
-   *
-   * Returns production server entry template that uses:
-   * - shovel:config virtual module for configuration
-   * - Worker threads via ServiceWorkerPool for multi-worker scaling
-   * - Platform's loadServiceWorker and createServer methods
+   * Get production entry points for bundling.
    *
-   * The template is a real .ts file (entry-template.ts) for better
-   * IDE support and linting. It's imported with {type: "text"}.
+   * 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) {
-    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
@@ -385,36 +428,74 @@ var NodePlatform = class extends BasePlatform {
    * Note: Node.js doesn't support import.meta.env natively, so we alias it
    * to process.env for compatibility with code that uses Vite-style env access.
    */
-  getEsbuildConfig() {
+  getESBuildConfig() {
     return {
       platform: "node",
-      external: ["node:*"],
+      external: ["node:*", ...builtinModules],
       define: {
         // Node.js doesn't support import.meta.env, alias to process.env
         "import.meta.env": "process.env"
       }
     };
   }
+  /**
+   * Get Node.js-specific defaults for config generation
+   *
+   * Provides default directories (server, public, tmp) that work
+   * out of the box for Node.js 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 (Node.js-specific implementation)
+   */
+  tmpdir() {
+    return tmpdir();
+  }
 };
 var src_default = NodePlatform;
 export {
+  MemoryCache2 as DefaultCache,
   NodePlatform,
+  NodeServiceWorkerContainer,
   src_default as default
 };