@b9g/platform-node 0.1.6 → 0.1.8

package/README.md

@@ -0,0 +1,128 @@
+# @b9g/platform-node
+
+Node.js platform adapter for Shovel. Runs ServiceWorker applications on Node.js with HTTP server integration, hot reloading, and worker thread concurrency.
+
+## Features
+
+- Node.js HTTP server with Web API Request/Response conversion
+- 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
+- ServiceWorker lifecycle support (install, activate, fetch events)
+
+## Installation
+
+```bash
+npm install @b9g/platform-node @b9g/platform @b9g/cache @b9g/filesystem
+```
+
+## Usage
+
+### Basic Server
+
+```javascript
+import NodePlatform from '@b9g/platform-node';
+
+const platform = new NodePlatform({
+  caches: { type: 'memory' },
+  filesystem: { type: 'local', directory: './dist' }
+});
+
+const server = platform.createServer(async (request) => {
+  return new Response('Hello from Node.js');
+}, { port: 3000, host: 'localhost' });
+
+await server.listen();
+console.log('Server running at http://localhost:3000');
+```
+
+### ServiceWorker App
+
+```javascript
+import NodePlatform from '@b9g/platform-node';
+
+const platform = new NodePlatform({
+  cwd: process.cwd()
+});
+
+// Load ServiceWorker entrypoint
+const instance = await platform.loadServiceWorker('./src/server.js', {
+  workerCount: 4 // Number of worker threads
+});
+
+// ServiceWorker is now handling requests
+```
+
+## Exports
+
+### Classes
+
+- `NodePlatform` - Node.js platform implementation (extends BasePlatform)
+
+### Re-exports from @b9g/platform
+
+- `Platform`, `CacheConfig`, `StaticConfig`, `Handler`, `Server`, `ServerOptions`
+
+### Default Export
+
+- `NodePlatform` - The platform class
+
+## API
+
+### `new NodePlatform(options?)`
+
+Creates a new Node.js platform instance.
+
+**Options:**
+- `caches`: Cache configuration object (see @b9g/platform)
+- `filesystem`: Filesystem configuration object
+- `port`: Default port for servers (default: 3000)
+- `host`: Default host for servers (default: localhost)
+- `cwd`: Working directory for file resolution (default: process.cwd())
+
+### `platform.createServer(handler, options): Server`
+
+Creates an HTTP server with automatic Request/Response conversion.
+
+**Parameters:**
+- `handler`: `(request: Request) => Promise<Response>` - Request handler function
+- `options`: Server options (port, host)
+
+**Returns:** Server instance with:
+- `listen()`: Start the server
+- `close()`: Stop the server
+- `url`: Server URL (after listen)
+- `ready`: Promise that resolves when server is ready
+
+### `platform.loadServiceWorker(entrypoint, options): Promise<ServiceWorkerInstance>`
+
+Loads and runs a ServiceWorker entrypoint.
+
+**Parameters:**
+- `entrypoint`: Path to ServiceWorker entry file
+- `options`: ServiceWorker options (workerCount, caches, etc.)
+
+**Returns:** ServiceWorkerInstance with:
+- `handleRequest(request)`: Handle a request through the ServiceWorker
+- `ready`: Promise that resolves when ServiceWorker is ready
+
+## Cache Backends
+
+Configured via `caches` option:
+
+- `memory`: In-memory caching (MemoryCache)
+- `filesystem`: File-based caching (NodeBucket)
+
+## Worker Thread Architecture
+
+The Node.js platform uses worker threads for true concurrency:
+
+- Each worker runs the ServiceWorker code in isolation
+- Round-robin load balancing across workers
+- Shared cache storage coordinated via PostMessage
+- Automatic request timeout (30s default)
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-node",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Node.js platform adapter for Shovel with hot reloading and ESBuild integration",
   "keywords": [
     "shovel",
@@ -11,10 +11,7 @@
     "esbuild"
   ],
   "dependencies": {
-    "@b9g/platform": "^0.1.4",
-    "@b9g/cache": "^0.1.3",
-    "@remix-run/node-fetch-server": "^0.11.0",
-    "@aws-sdk/client-s3": "^3.0.0"
+    "@b9g/platform": "^0.1.6"
   },
   "devDependencies": {
     "@b9g/libuild": "^0.1.11",
@@ -29,14 +26,6 @@
       "types": "./src/index.d.ts",
       "import": "./src/index.js"
     },
-    "./platform": {
-      "types": "./src/platform.d.ts",
-      "import": "./src/platform.js"
-    },
-    "./platform.js": {
-      "types": "./src/platform.d.ts",
-      "import": "./src/platform.js"
-    },
     "./package.json": "./package.json",
     "./index": {
       "types": "./src/index.d.ts",

package/src/index.d.ts

@@ -3,5 +3,58 @@
  *
  * Provides hot reloading, ESBuild integration, and optimized caching for Node.js environments.
  */
-export { NodePlatform, createNodePlatform, type NodePlatformOptions, } from "./platform.js";
-export type { Platform, CacheConfig, StaticConfig, Handler, Server, ServerOptions, } from "@b9g/platform";
+import { BasePlatform, PlatformConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance, ServiceWorkerPool } from "@b9g/platform";
+import { CustomCacheStorage } from "@b9g/cache";
+export type { Platform, Handler, Server, ServerOptions } from "@b9g/platform";
+export interface NodePlatformOptions extends PlatformConfig {
+    /** Port for development server (default: 3000) */
+    port?: number;
+    /** Host for development server (default: localhost) */
+    host?: string;
+    /** Working directory for file resolution */
+    cwd?: string;
+}
+/**
+ * Node.js platform implementation
+ * ServiceWorker entrypoint loader for Node.js with ESBuild VM system
+ */
+export declare class NodePlatform extends BasePlatform {
+    #private;
+    readonly name: string;
+    constructor(options?: NodePlatformOptions);
+    /**
+     * Get options for testing
+     */
+    get options(): Required<NodePlatformOptions>;
+    /**
+     * 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>;
+    /**
+     * SUPPORTING UTILITY - Create cache storage
+     * Uses config from package.json shovel field
+     */
+    createCaches(): Promise<CustomCacheStorage>;
+    /**
+     * SUPPORTING UTILITY - Create HTTP server for Node.js
+     */
+    createServer(handler: Handler, options?: ServerOptions): Server;
+    /**
+     * Reload workers for hot reloading (called by CLI)
+     */
+    reloadWorkers(version?: number | string): Promise<void>;
+    /**
+     * Dispose of platform resources
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Default export for easy importing
+ */
+export default NodePlatform;

package/src/index.js

@@ -1,10 +1,312 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
 import {
-  NodePlatform,
-  createNodePlatform
-} from "./platform.js";
+  BasePlatform,
+  ServiceWorkerPool,
+  SingleThreadedRuntime,
+  loadConfig,
+  createCacheFactory
+} from "@b9g/platform";
+import { CustomCacheStorage } from "@b9g/cache";
+import * as HTTP from "http";
+import * as Path from "path";
+import { getLogger } from "@logtape/logtape";
+var logger = getLogger(["platform-node"]);
+var NodePlatform = class extends BasePlatform {
+  name;
+  #options;
+  #workerPool;
+  #singleThreadedRuntime;
+  #cacheStorage;
+  #config;
+  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,
+      cwd,
+      ...options
+    };
+  }
+  /**
+   * Get options for testing
+   */
+  get options() {
+    return this.#options;
+  }
+  /**
+   * Get/set worker pool for testing
+   */
+  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.#config.workers ?? 1;
+    if (workerCount === 1 && !options.hotReload) {
+      return this.#loadServiceWorkerDirect(entrypoint, options);
+    }
+    return this.#loadServiceWorkerWithPool(entrypoint, options, workerCount);
+  }
+  /**
+   * Load ServiceWorker directly in main thread (single-threaded mode)
+   * No postMessage overhead - maximum performance for production
+   */
+  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.#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({
+      baseDir: entryDir,
+      cacheStorage: this.#cacheStorage,
+      config: this.#config
+    });
+    await this.#singleThreadedRuntime.init();
+    const version = Date.now();
+    await this.#singleThreadedRuntime.loadEntrypoint(entryPath, version);
+    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;
+  }
+  /**
+   * Load ServiceWorker using worker pool (multi-threaded mode or dev mode)
+   */
+  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,
+      this.#config
+    );
+    await this.#workerPool.init();
+    const version = Date.now();
+    await this.#workerPool.reloadWorkers(version);
+    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;
+  }
+  /**
+   * SUPPORTING UTILITY - Create cache storage
+   * Uses config from package.json shovel field
+   */
+  async createCaches() {
+    return new CustomCacheStorage(createCacheFactory({ config: this.#config }));
+  }
+  /**
+   * SUPPORTING UTILITY - Create HTTP server for Node.js
+   */
+  createServer(handler, options = {}) {
+    const port = options.port ?? this.#options.port;
+    const host = options.host ?? this.#options.host;
+    const httpServer = HTTP.createServer(async (req, res) => {
+      try {
+        const url = `http://${req.headers.host}${req.url}`;
+        const request = new Request(url, {
+          method: req.method,
+          headers: req.headers,
+          // Node.js IncomingMessage can be used as body (it's a readable stream)
+          body: req.method !== "GET" && req.method !== "HEAD" ? req : void 0
+        });
+        const response = await handler(request);
+        res.statusCode = response.status;
+        res.statusMessage = response.statusText;
+        response.headers.forEach((value, key) => {
+          res.setHeader(key, value);
+        });
+        if (response.body) {
+          const reader = response.body.getReader();
+          const pump = async () => {
+            const { done, value } = await reader.read();
+            if (done) {
+              res.end();
+            } else {
+              res.write(value);
+              await pump();
+            }
+          };
+          await pump();
+        } else {
+          res.end();
+        }
+      } catch (error) {
+        logger.error("Request error", {
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "text/plain");
+        res.end("Internal Server Error");
+      }
+    });
+    let isListening = false;
+    let actualPort = port;
+    return {
+      async listen() {
+        return new Promise((resolve2, reject) => {
+          httpServer.listen(port, host, () => {
+            const addr = httpServer.address();
+            if (addr && typeof addr === "object") {
+              actualPort = addr.port;
+            }
+            logger.info("Server started", {
+              host,
+              port: actualPort,
+              url: `http://${host}:${actualPort}`
+            });
+            isListening = true;
+            resolve2();
+          });
+          httpServer.on("error", (error) => {
+            reject(error);
+          });
+        });
+      },
+      async close() {
+        return new Promise((resolve2) => {
+          httpServer.close(() => {
+            isListening = false;
+            resolve2();
+          });
+        });
+      },
+      address: () => ({ port: actualPort, host }),
+      get url() {
+        return `http://${host}:${actualPort}`;
+      },
+      get ready() {
+        return isListening;
+      }
+    };
+  }
+  /**
+   * Reload workers for hot reloading (called by CLI)
+   */
+  async reloadWorkers(version) {
+    if (this.#workerPool) {
+      await this.#workerPool.reloadWorkers(version);
+    } else if (this.#singleThreadedRuntime) {
+      await this.#singleThreadedRuntime.reloadWorkers(version);
+    }
+  }
+  /**
+   * 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;
+    }
+  }
+};
+var src_default = NodePlatform;
 export {
   NodePlatform,
-  createNodePlatform
+  src_default as default
 };

package/src/platform.d.ts

@@ -1,71 +0,0 @@
-/**
- * Node.js platform implementation - ServiceWorker entrypoint loader for Node.js
- *
- * Handles the complex ESBuild VM system, hot reloading, and module linking
- * to make ServiceWorker-style apps run in Node.js environments.
- */
-import { BasePlatform, PlatformConfig, CacheConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance } from "@b9g/platform";
-import { CustomCacheStorage } from "@b9g/cache";
-export interface NodePlatformOptions extends PlatformConfig {
-    /** Enable hot reloading (default: true in development) */
-    hotReload?: boolean;
-    /** Port for development server (default: 3000) */
-    port?: number;
-    /** Host for development server (default: localhost) */
-    host?: string;
-    /** Working directory for file resolution */
-    cwd?: string;
-}
-/**
- * Node.js platform implementation
- * ServiceWorker entrypoint loader for Node.js with ESBuild VM system
- */
-export declare class NodePlatform extends BasePlatform {
-    readonly name = "node";
-    private options;
-    private workerPool?;
-    private cacheStorage?;
-    constructor(options?: NodePlatformOptions);
-    /**
-     * Get filesystem directory handle
-     */
-    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * 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>;
-    /**
-     * Get platform-specific default cache configuration for Node.js
-     */
-    protected getDefaultCacheConfig(): CacheConfig;
-    /**
-     * SUPPORTING UTILITY - Create cache storage optimized for Node.js
-     * Uses MemoryCache in main thread, PostMessageCache in workers
-     */
-    createCaches(config?: CacheConfig): Promise<CustomCacheStorage>;
-    /**
-     * SUPPORTING UTILITY - Create HTTP server for Node.js
-     */
-    createServer(handler: Handler, options?: ServerOptions): Server;
-    /**
-     * Get filesystem root for File System Access API
-     */
-    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * Reload workers for hot reloading (called by CLI)
-     */
-    reloadWorkers(version?: number | string): Promise<void>;
-    /**
-     * Dispose of platform resources
-     */
-    dispose(): Promise<void>;
-}
-/**
- * Create a Node.js platform instance
- */
-export declare function createNodePlatform(options?: NodePlatformOptions): NodePlatform;
-/**
- * Default export for easy importing
- */
-export default createNodePlatform;

package/src/platform.js

@@ -1,265 +0,0 @@
-/// <reference types="./platform.d.ts" />
-// src/platform.ts
-import {
-  BasePlatform
-} from "@b9g/platform";
-import { WorkerPool } from "@b9g/platform/worker-pool";
-import { CustomCacheStorage, MemoryCache, MemoryCacheManager, PostMessageCache } from "@b9g/cache";
-import { FileSystemRegistry, getDirectoryHandle, LocalBucket } from "@b9g/filesystem";
-import * as Http from "http";
-import * as Path from "path";
-var NodeWorkerPool = class extends WorkerPool {
-  memoryCacheManager;
-  constructor(cacheStorage, poolOptions, appEntrypoint) {
-    super(cacheStorage, poolOptions, appEntrypoint);
-    this.memoryCacheManager = new MemoryCacheManager();
-    console.info(
-      "[NodeWorkerPool] Initialized with entrypoint:",
-      appEntrypoint
-    );
-  }
-  /**
-   * Handle Node.js-specific cache coordination
-   */
-  handleCacheMessage(message) {
-    if (message.type?.startsWith("cache:")) {
-      console.warn("[NodeWorkerPool] Cache coordination not fully implemented in abstraction");
-    }
-  }
-  /**
-   * Enhanced termination with memory cache cleanup
-   */
-  async terminate() {
-    await super.terminate();
-    await this.memoryCacheManager.dispose();
-  }
-};
-var NodePlatform = class extends BasePlatform {
-  name = "node";
-  options;
-  workerPool;
-  cacheStorage;
-  constructor(options = {}) {
-    super(options);
-    this.options = {
-      hotReload: process.env.NODE_ENV !== "production",
-      port: 3e3,
-      host: "localhost",
-      cwd: process.cwd(),
-      ...options
-    };
-    FileSystemRegistry.register("node", new LocalBucket({
-      rootPath: this.options.cwd
-    }));
-  }
-  /**
-   * Get filesystem directory handle
-   */
-  async getDirectoryHandle(name) {
-    const distPath = Path.resolve(this.options.cwd, "dist");
-    const adapter = new LocalBucket({ rootPath: distPath });
-    return await adapter.getDirectoryHandle(name);
-  }
-  /**
-   * 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 entryPath = Path.resolve(this.options.cwd, entrypoint);
-    if (!this.cacheStorage) {
-      this.cacheStorage = await this.createCaches(options.caches);
-    }
-    if (this.workerPool) {
-      await this.workerPool.terminate();
-    }
-    const workerCount = options.workerCount || 1;
-    console.info(
-      "[Platform-Node] Creating NodeWorkerPool with entryPath:",
-      entryPath
-    );
-    this.workerPool = new NodeWorkerPool(
-      this.cacheStorage,
-      {
-        workerCount,
-        requestTimeout: 3e4,
-        hotReload: this.options.hotReload,
-        cwd: this.options.cwd
-      },
-      entryPath
-    );
-    await this.workerPool.init();
-    const version = Date.now();
-    await this.workerPool.reloadWorkers(version);
-    const instance = {
-      runtime: this.workerPool,
-      handleRequest: async (request) => {
-        if (!this.workerPool) {
-          throw new Error("NodeWorkerPool not initialized");
-        }
-        return this.workerPool.handleRequest(request);
-      },
-      install: async () => {
-        console.info(
-          "[Platform-Node] ServiceWorker installed via Worker threads"
-        );
-      },
-      activate: async () => {
-        console.info(
-          "[Platform-Node] ServiceWorker activated via Worker threads"
-        );
-      },
-      collectStaticRoutes: async () => {
-        return [];
-      },
-      get ready() {
-        return this.workerPool?.ready ?? false;
-      },
-      dispose: async () => {
-        if (this.workerPool) {
-          await this.workerPool.terminate();
-          this.workerPool = void 0;
-        }
-        console.info("[Platform-Node] ServiceWorker disposed");
-      }
-    };
-    console.info(
-      "[Platform-Node] ServiceWorker loaded with Worker threads and coordinated caches"
-    );
-    return instance;
-  }
-  /**
-   * Get platform-specific default cache configuration for Node.js
-   */
-  getDefaultCacheConfig() {
-    return {
-      pages: { type: "memory" },
-      // PostMessage cache for worker coordination
-      api: { type: "memory" },
-      static: { type: "memory" }
-    };
-  }
-  /**
-   * SUPPORTING UTILITY - Create cache storage optimized for Node.js
-   * Uses MemoryCache in main thread, PostMessageCache in workers
-   */
-  async createCaches(config) {
-    const { isMainThread } = await import("worker_threads");
-    return new CustomCacheStorage((name) => {
-      if (isMainThread) {
-        return new MemoryCache(name, {
-          maxEntries: 1e3,
-          maxAge: 60 * 60 * 1e3
-          // 1 hour
-        });
-      } else {
-        return new PostMessageCache(name, {
-          maxEntries: 1e3,
-          maxAge: 60 * 60 * 1e3
-          // 1 hour
-        });
-      }
-    });
-  }
-  /**
-   * SUPPORTING UTILITY - Create HTTP server for Node.js
-   */
-  createServer(handler, options = {}) {
-    const port = options.port ?? this.options.port;
-    const host = options.host ?? this.options.host;
-    const httpServer = Http.createServer(async (req, res) => {
-      try {
-        const url = `http://${req.headers.host}${req.url}`;
-        const request = new Request(url, {
-          method: req.method,
-          headers: req.headers,
-          body: req.method !== "GET" && req.method !== "HEAD" ? req : void 0
-        });
-        const response = await handler(request);
-        res.statusCode = response.status;
-        res.statusMessage = response.statusText;
-        response.headers.forEach((value, key) => {
-          res.setHeader(key, value);
-        });
-        if (response.body) {
-          const reader = response.body.getReader();
-          const pump = async () => {
-            const { done, value } = await reader.read();
-            if (done) {
-              res.end();
-            } else {
-              res.write(value);
-              await pump();
-            }
-          };
-          await pump();
-        } else {
-          res.end();
-        }
-      } catch (error) {
-        console.error("[Platform-Node] Request error:", error);
-        res.statusCode = 500;
-        res.setHeader("Content-Type", "text/plain");
-        res.end("Internal Server Error");
-      }
-    });
-    let isListening = false;
-    return {
-      async listen() {
-        return new Promise((resolve2) => {
-          httpServer.listen(port, host, () => {
-            console.info(`\u{1F680} Server running at http://${host}:${port}`);
-            isListening = true;
-            resolve2();
-          });
-        });
-      },
-      async close() {
-        return new Promise((resolve2) => {
-          httpServer.close(() => {
-            isListening = false;
-            resolve2();
-          });
-        });
-      },
-      address: () => ({ port, host }),
-      get url() {
-        return `http://${host}:${port}`;
-      },
-      get ready() {
-        return isListening;
-      }
-    };
-  }
-  /**
-   * Get filesystem root for File System Access API
-   */
-  async getFileSystemRoot(name = "default") {
-    return await getDirectoryHandle(name);
-  }
-  /**
-   * Reload workers for hot reloading (called by CLI)
-   */
-  async reloadWorkers(version) {
-    if (this.workerPool) {
-      await this.workerPool.reloadWorkers(version);
-    }
-  }
-  /**
-   * Dispose of platform resources
-   */
-  async dispose() {
-    if (this.workerPool) {
-      await this.workerPool.terminate();
-      this.workerPool = void 0;
-    }
-  }
-};
-function createNodePlatform(options) {
-  return new NodePlatform(options);
-}
-var platform_default = createNodePlatform;
-export {
-  NodePlatform,
-  createNodePlatform,
-  platform_default as default
-};