@b9g/platform-node 0.1.12 → 0.1.13

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.13",
   "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.13",
     "@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,7 +3,8 @@
  *
  * 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 { 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";
 export interface NodePlatformOptions extends PlatformConfig {
@@ -15,6 +16,8 @@ export interface NodePlatformOptions extends PlatformConfig {
     cwd?: string;
     /** Number of worker threads (default: 1) */
     workers?: number;
+    /** Shovel configuration (caches, directories, etc.) */
+    config?: ShovelConfig;
 }
 /**
  * Node.js platform implementation
@@ -27,7 +30,13 @@ export declare class NodePlatform extends BasePlatform {
     /**
      * Get options for testing
      */
-    get options(): Required<NodePlatformOptions>;
+    get options(): {
+        port: number;
+        host: string;
+        cwd: string;
+        workers: number;
+        config?: ShovelConfig;
+    };
     /**
      * Get/set worker pool for testing
      */
@@ -39,13 +48,25 @@ export declare class NodePlatform extends BasePlatform {
      */
     loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
     /**
-     * Create cache storage (in-memory by default)
+     * 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
      */
     createCaches(): Promise<CustomCacheStorage>;
     /**
-     * Create directory storage for the given base directory
+     * 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
      */
-    createDirectories(baseDir: string): CustomDirectoryStorage;
+    createDirectories(): Promise<CustomDirectoryStorage>;
+    /**
+     * Create logger storage using config from shovel.json
+     */
+    createLoggers(): Promise<CustomLoggerStorage>;
+    /**
+     * Create database storage from declarative config in shovel.json
+     */
+    createDatabases(configOverride?: NodePlatformOptions["config"]): CustomDatabaseStorage | undefined;
     /**
      * SUPPORTING UTILITY - Create HTTP server for Node.js
      */
@@ -58,28 +79,44 @@ export declare class NodePlatform extends BasePlatform {
     /**
      * 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
+     * @param entryPath - Absolute path to user's entrypoint file
+     * @param options - Entry wrapper options
+     * @param options.type - "production" (default) or "worker"
      *
-     * The template is a real .ts file (entry-template.ts) for better
-     * IDE support and linting. It's imported with {type: "text"}.
+     * Returns:
+     * - "production": Server entry that loads ServiceWorkerPool
+     * - "worker": Worker entry that sets up runtime and message loop
      */
-    getEntryWrapper(_entryPath: string, _options?: EntryWrapperOptions): string;
+    getEntryWrapper(entryPath: string, options?: EntryWrapperOptions): string;
     /**
      * 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,21 +1,33 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
+import { builtinModules } from "node:module";
+import { tmpdir } from "node:os";
 import {
   BasePlatform,
   ServiceWorkerPool,
   SingleThreadedRuntime,
-  CustomLoggerStorage
+  CustomLoggerStorage,
+  CustomDatabaseStorage,
+  createDatabaseFactory
 } from "@b9g/platform";
+import {
+  createCacheFactory,
+  createDirectoryFactory
+} from "@b9g/platform/runtime";
 import { CustomCacheStorage } from "@b9g/cache";
-import { CustomDirectoryStorage } from "@b9g/filesystem";
 import { MemoryCache } from "@b9g/cache/memory";
-import { NodeDirectory } from "@b9g/filesystem/node";
+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
-// This file is imported as text and used as the entry wrapper template
+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
@@ -24,52 +36,177 @@ import Platform from "@b9g/platform-node";
 // Configure logging before anything else
 await configureLogging(config.logging);
 
-const logger = getLogger(["platform"]);
+const logger = getLogger(["shovel", "platform"]);
 
-// Configuration from shovel:config (with process.env fallbacks baked in)
+// Configuration from shovel:config
 const PORT = config.port;
 const HOST = config.host;
-const WORKER_COUNT = config.workers;
+const WORKERS = config.workers;
 
-logger.info("Starting production server", {});
-logger.info("Workers", {count: WORKER_COUNT});
+// 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";
 
-// Create platform instance
-const platform = new Platform();
+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});
 
-// Get the path to the user's ServiceWorker code
-const userCodeURL = new URL("./server.js", import.meta.url);
-const userCodePath = userCodeURL.pathname;
+		// Track resources for shutdown - these get assigned during startup
+		let server;
+		let serviceWorker;
 
-// Load ServiceWorker with worker pool
-const serviceWorker = await platform.loadServiceWorker(userCodePath, {
-	workerCount: WORKER_COUNT,
-});
+		// 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"});
+			}
+		};
 
-// Create HTTP server
-const server = platform.createServer(serviceWorker.handleRequest, {
-	port: PORT,
-	host: HOST,
-});
+		const userCodePath = new URL("./server.js", import.meta.url).pathname;
+		serviceWorker = await platform.loadServiceWorker(userCodePath);
 
-await server.listen();
-logger.info("Server running", {url: \`http://\${HOST}:\${PORT}\`});
-logger.info("Load balancing", {workers: WORKER_COUNT});
+		server = platform.createServer(serviceWorker.handleRequest, {
+			port: PORT,
+			host: HOST,
+		});
+		await server.listen();
 
-// 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);
-};
+		// 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,
+		});
 
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
+		// 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 logger = getLogger(["platform"]);
+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 NodePlatform = class extends BasePlatform {
   name;
   #options;
@@ -77,6 +214,7 @@ var NodePlatform = class extends BasePlatform {
   #singleThreadedRuntime;
   #cacheStorage;
   #directoryStorage;
+  #databaseStorage;
   constructor(options = {}) {
     super(options);
     this.name = "node";
@@ -86,7 +224,7 @@ var NodePlatform = class extends BasePlatform {
       host: options.host ?? "localhost",
       workers: options.workers ?? 1,
       cwd,
-      ...options
+      config: options.config
     };
   }
   /**
@@ -121,12 +259,55 @@ var NodePlatform = class extends BasePlatform {
    */
   async #loadServiceWorkerDirect(entrypoint, _options) {
     const entryPath = Path.resolve(this.#options.cwd, entrypoint);
-    const entryDir = Path.dirname(entryPath);
+    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 = await this.createCaches();
+      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) {
-      this.#directoryStorage = this.createDirectories(entryDir);
+      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();
@@ -139,7 +320,8 @@ var NodePlatform = class extends BasePlatform {
     this.#singleThreadedRuntime = new SingleThreadedRuntime({
       caches: this.#cacheStorage,
       directories: this.#directoryStorage,
-      loggers: new CustomLoggerStorage((...cats) => getLogger(cats))
+      databases: this.#databaseStorage,
+      loggers: new CustomLoggerStorage((cats) => getLogger(cats))
     });
     await this.#singleThreadedRuntime.init();
     await this.#singleThreadedRuntime.load(entryPath);
@@ -180,8 +362,20 @@ var NodePlatform = class extends BasePlatform {
    */
   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 = await this.createCaches();
+      this.#cacheStorage = new CustomCacheStorage(
+        createCacheFactory({
+          configs: config?.caches ?? {}
+        })
+      );
     }
     if (this.#singleThreadedRuntime) {
       await this.#singleThreadedRuntime.terminate();
@@ -201,12 +395,9 @@ var NodePlatform = class extends BasePlatform {
         cwd: this.#options.cwd
       },
       entryPath,
-      this.#cacheStorage,
-      {}
-      // Empty config - use defaults
+      this.#cacheStorage
     );
     await this.#workerPool.init();
-    await this.#workerPool.reloadWorkers(entryPath);
     const workerPool = this.#workerPool;
     const platform = this;
     const instance = {
@@ -244,26 +435,63 @@ var NodePlatform = class extends BasePlatform {
     return instance;
   }
   /**
-   * Create cache storage (in-memory by default)
+   * 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
    */
   async createCaches() {
-    return new CustomCacheStorage((name) => new MemoryCache(name));
+    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] };
+    }
+    return new CustomCacheStorage(createCacheFactory({ configs }));
   }
   /**
-   * Create directory storage for the given base directory
+   * 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
    */
-  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));
-    });
+  async createDirectories() {
+    const runtimeDefaults = {
+      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] };
+    }
+    return new CustomDirectoryStorage(createDirectoryFactory(configs));
+  }
+  /**
+   * Create logger storage using config from shovel.json
+   */
+  async createLoggers() {
+    return new CustomLoggerStorage((categories) => getLogger(categories));
+  }
+  /**
+   * Create database storage from declarative config in shovel.json
+   */
+  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
@@ -368,15 +596,18 @@ var NodePlatform = class extends BasePlatform {
   /**
    * 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
+   * @param entryPath - Absolute path to user's entrypoint file
+   * @param options - Entry wrapper options
+   * @param options.type - "production" (default) or "worker"
    *
-   * The template is a real .ts file (entry-template.ts) for better
-   * IDE support and linting. It's imported with {type: "text"}.
+   * Returns:
+   * - "production": Server entry that loads ServiceWorkerPool
+   * - "worker": Worker entry that sets up runtime and message loop
    */
-  getEntryWrapper(_entryPath, _options) {
+  getEntryWrapper(entryPath, options) {
+    if (options?.type === "worker") {
+      return workerEntryTemplate.replace("__USER_ENTRY__", entryPath);
+    }
     return entryTemplate;
   }
   /**
@@ -385,16 +616,49 @@ 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
    */
@@ -411,10 +675,24 @@ var NodePlatform = class extends BasePlatform {
       await this.#cacheStorage.dispose();
       this.#cacheStorage = void 0;
     }
+    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,
   src_default as default
 };