@b9g/platform-node 0.1.11 → 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 NodeBucket
+- 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 (NodeBucket)
+- `filesystem`: File-based caching (NodeFSDirectory)
 
 ## Worker Thread Architecture
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-node",
-  "version": "0.1.11",
+  "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.4",
-    "@b9g/http-errors": "^0.1.5",
-    "@b9g/platform": "^0.1.10",
+    "@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,9 +3,10 @@
  *
  * Provides hot reloading, ESBuild integration, and optimized caching for Node.js environments.
  */
-import { BasePlatform, PlatformConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance, 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";
-export type { Platform, Handler, Server, ServerOptions } from "@b9g/platform";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
 export interface NodePlatformOptions extends PlatformConfig {
     /** Port for development server (default: 3000) */
     port?: number;
@@ -13,6 +14,10 @@ export interface NodePlatformOptions extends PlatformConfig {
     host?: string;
     /** Working directory for file resolution */
     cwd?: string;
+    /** Number of worker threads (default: 1) */
+    workers?: number;
+    /** Shovel configuration (caches, directories, etc.) */
+    config?: ShovelConfig;
 }
 /**
  * Node.js platform implementation
@@ -25,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
      */
@@ -37,10 +48,25 @@ export declare class NodePlatform extends BasePlatform {
      */
     loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
     /**
-     * SUPPORTING UTILITY - Create cache storage
-     * Uses config from package.json shovel field
+     * 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 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(): 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
      */
@@ -50,12 +76,47 @@ export declare class NodePlatform extends BasePlatform {
      * @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"
+     *
+     * Returns:
+     * - "production": Server entry that loads ServiceWorkerPool
+     * - "worker": Worker entry that sets up runtime and message loop
+     */
+    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;
+    /**
+     * 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,36 +1,230 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
+import { builtinModules } from "node:module";
+import { tmpdir } from "node:os";
 import {
   BasePlatform,
   ServiceWorkerPool,
   SingleThreadedRuntime,
-  loadConfig,
-  createCacheFactory
+  CustomLoggerStorage,
+  CustomDatabaseStorage,
+  createDatabaseFactory
 } from "@b9g/platform";
+import {
+  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";
-var logger = getLogger(["platform-node"]);
+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 NodePlatform = class extends BasePlatform {
   name;
   #options;
   #workerPool;
   #singleThreadedRuntime;
   #cacheStorage;
-  #config;
+  #directoryStorage;
+  #databaseStorage;
   constructor(options = {}) {
     super(options);
     this.name = "node";
     const cwd = options.cwd || process.cwd();
-    this.#config = loadConfig(cwd);
-    logger.info("Loaded configuration", { config: this.#config });
     this.#options = {
-      port: options.port ?? this.#config.port,
-      host: options.host ?? this.#config.host,
+      port: options.port ?? 3e3,
+      host: options.host ?? "localhost",
+      workers: options.workers ?? 1,
       cwd,
-      ...options
+      config: options.config
     };
   }
   /**
@@ -53,7 +247,7 @@ var NodePlatform = class extends BasePlatform {
    * Uses Worker threads with coordinated cache storage for isolation and standards compliance
    */
   async loadServiceWorker(entrypoint, options = {}) {
-    const workerCount = options.workerCount ?? this.#config.workers ?? 1;
+    const workerCount = options.workerCount ?? this.#options.workers;
     if (workerCount === 1 && !options.hotReload) {
       return this.#loadServiceWorkerDirect(entrypoint, options);
     }
@@ -65,9 +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) {
+      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();
@@ -78,12 +318,13 @@ var NodePlatform = class extends BasePlatform {
     }
     logger.info("Creating single-threaded ServiceWorker runtime", { entryPath });
     this.#singleThreadedRuntime = new SingleThreadedRuntime({
-      baseDir: entryDir,
-      cacheStorage: this.#cacheStorage,
-      config: this.#config
+      caches: this.#cacheStorage,
+      directories: this.#directoryStorage,
+      databases: this.#databaseStorage,
+      loggers: new CustomLoggerStorage((cats) => getLogger(cats))
     });
     await this.#singleThreadedRuntime.init();
-    await this.#singleThreadedRuntime.loadEntrypoint(entryPath);
+    await this.#singleThreadedRuntime.load(entryPath);
     const runtime = this.#singleThreadedRuntime;
     const platform = this;
     const instance = {
@@ -121,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();
@@ -142,11 +395,9 @@ var NodePlatform = class extends BasePlatform {
         cwd: this.#options.cwd
       },
       entryPath,
-      this.#cacheStorage,
-      this.#config
+      this.#cacheStorage
     );
     await this.#workerPool.init();
-    await this.#workerPool.reloadWorkers(entryPath);
     const workerPool = this.#workerPool;
     const platform = this;
     const instance = {
@@ -184,11 +435,63 @@ var NodePlatform = class extends BasePlatform {
     return instance;
   }
   /**
-   * SUPPORTING UTILITY - Create cache storage
-   * Uses config from package.json shovel field
+   * 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(createCacheFactory({ config: this.#config }));
+    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 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 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
@@ -228,10 +531,7 @@ var NodePlatform = class extends BasePlatform {
         }
       } catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
-        logger.error("Request error", {
-          error: err.message,
-          stack: err.stack
-        });
+        logger.error("Request error: {error}", { error: err });
         const httpError = isHTTPError(error) ? error : new InternalServerError(err.message, { cause: err });
         const isDev = import.meta.env?.MODE !== "production";
         const response = httpError.toResponse(isDev);
@@ -290,9 +590,75 @@ var NodePlatform = class extends BasePlatform {
     if (this.#workerPool) {
       await this.#workerPool.reloadWorkers(entrypoint);
     } else if (this.#singleThreadedRuntime) {
-      await this.#singleThreadedRuntime.reloadWorkers(entrypoint);
+      await this.#singleThreadedRuntime.load(entrypoint);
     }
   }
+  /**
+   * 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"
+   *
+   * Returns:
+   * - "production": Server entry that loads ServiceWorkerPool
+   * - "worker": Worker entry that sets up runtime and message loop
+   */
+  getEntryWrapper(entryPath, options) {
+    if (options?.type === "worker") {
+      return workerEntryTemplate.replace("__USER_ENTRY__", entryPath);
+    }
+    return entryTemplate;
+  }
+  /**
+   * 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() {
+    return {
+      platform: "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
    */
@@ -309,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
 };