@b9g/platform-bun 0.1.1 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Bun platform adapter for Shovel with hot reloading and built-in TypeScript/JSX support",
   "keywords": [
     "shovel",
@@ -12,12 +12,12 @@
     "jsx"
   ],
   "dependencies": {
-    "@b9g/platform": "^0.1.1",
-    "@b9g/cache": "^0.1.1",
-    "@b9g/assets": "^0.1.1"
+    "@b9g/platform": "^0.1.4",
+    "@b9g/cache": "^0.1.3",
+    "@b9g/assets": "^0.1.4"
   },
   "devDependencies": {
-    "@b9g/libuild": "^0.1.10",
+    "@b9g/libuild": "^0.1.11",
     "bun-types": "latest"
   },
   "type": "module",

package/src/platform.d.ts

@@ -23,18 +23,19 @@ export interface BunPlatformOptions extends PlatformConfig {
 export declare class BunPlatform extends BasePlatform {
     readonly name = "bun";
     private options;
-    private _dist?;
+    private workerPool?;
+    private cacheStorage?;
     constructor(options?: BunPlatformOptions);
     /**
      * Build artifacts filesystem (install-time only)
      */
-    get distDir(): FileSystemDirectoryHandle;
+    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
     /**
      * Get platform-specific default cache configuration for Bun
      */
     protected getDefaultCacheConfig(): CacheConfig;
     /**
-     * Override cache creation to use PostMessage coordination for Bun
+     * Override cache creation to use appropriate cache type for Bun
      */
     createCaches(config?: CacheConfig): Promise<CustomCacheStorage>;
     /**
@@ -43,12 +44,13 @@ export declare class BunPlatform extends BasePlatform {
     createServer(handler: Handler, options?: ServerOptions): Server;
     /**
      * Load and run a ServiceWorker-style entrypoint with Bun
+     * Uses native Web Workers with the common WorkerPool
      */
     loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
     /**
-     * Get filesystem root for File System Access API
+     * Reload workers for hot reloading (called by CLI)
      */
-    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    reloadWorkers(version?: number | string): Promise<void>;
     /**
      * Dispose of platform resources
      */

package/src/platform.js

@@ -1,18 +1,17 @@
 /// <reference types="./platform.d.ts" />
 // src/platform.ts
 import {
-  BasePlatform,
-  ServiceWorkerRuntime,
-  createServiceWorkerGlobals,
-  createDirectoryStorage
+  BasePlatform
 } from "@b9g/platform";
+import { WorkerPool } from "@b9g/platform/worker-pool";
 import { CustomCacheStorage, PostMessageCache } from "@b9g/cache";
-import { FileSystemRegistry, getFileSystemRoot, MemoryFileSystemAdapter, NodeFileSystemAdapter, BunS3FileSystemAdapter } from "@b9g/filesystem";
+import { FileSystemRegistry, MemoryBucket, LocalBucket } from "@b9g/filesystem";
 import * as Path from "path";
 var BunPlatform = class extends BasePlatform {
   name = "bun";
   options;
-  _dist;
+  workerPool;
+  cacheStorage;
   constructor(options = {}) {
     super(options);
     this.options = {
@@ -22,8 +21,8 @@ var BunPlatform = class extends BasePlatform {
       cwd: process.cwd(),
       ...options
     };
-    FileSystemRegistry.register("memory", new MemoryFileSystemAdapter());
-    FileSystemRegistry.register("node", new NodeFileSystemAdapter({
+    FileSystemRegistry.register("memory", new MemoryBucket());
+    FileSystemRegistry.register("node", new LocalBucket({
       rootPath: Path.join(this.options.cwd, "dist")
     }));
     try {
@@ -38,12 +37,10 @@ var BunPlatform = class extends BasePlatform {
   /**
    * Build artifacts filesystem (install-time only)
    */
-  get distDir() {
-    if (!this._dist) {
-      const distPath = Path.resolve(this.options.cwd, "dist");
-      this._dist = new NodeFileSystemAdapter({ rootPath: distPath }).getFileSystemRoot("");
-    }
-    return this._dist;
+  async getDirectoryHandle(name) {
+    const distPath = Path.resolve(this.options.cwd, "dist");
+    const adapter = new LocalBucket({ rootPath: distPath });
+    return await adapter.getDirectoryHandle(name);
   }
   /**
    * Get platform-specific default cache configuration for Bun
@@ -57,15 +54,25 @@ var BunPlatform = class extends BasePlatform {
     };
   }
   /**
-   * Override cache creation to use PostMessage coordination for Bun
+   * Override cache creation to use appropriate cache type for Bun
    */
   async createCaches(config) {
+    const { MemoryCache } = await import("@b9g/cache");
+    const isWorkerThread = typeof self !== "undefined" && typeof window === "undefined";
     return new CustomCacheStorage((name) => {
-      return new PostMessageCache(name, {
-        maxEntries: 1e3,
-        maxSize: 50 * 1024 * 1024
-        // 50MB
-      });
+      if (!isWorkerThread) {
+        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
+        });
+      }
     });
   }
   /**
@@ -83,80 +90,94 @@ var BunPlatform = class extends BasePlatform {
       development: this.options.hotReload
     });
     return {
-      listen: () => {
+      async listen() {
         console.info(`\u{1F956} Bun server running at http://${hostname}:${port}`);
-        return Promise.resolve();
       },
-      close: () => {
+      async close() {
         server.stop();
-        return Promise.resolve();
       },
-      address: () => ({ port, host: hostname })
+      address: () => ({ port, host: hostname }),
+      get url() {
+        return `http://${hostname}:${port}`;
+      },
+      get ready() {
+        return true;
+      }
     };
   }
   /**
    * Load and run a ServiceWorker-style entrypoint with Bun
+   * Uses native Web Workers with the common WorkerPool
    */
   async loadServiceWorker(entrypoint, options = {}) {
-    const runtime = new ServiceWorkerRuntime();
     const entryPath = Path.resolve(this.options.cwd, entrypoint);
-    const caches = await this.createCaches(options.caches);
-    const dirs = createDirectoryStorage(this.distDir);
+    if (!this.cacheStorage) {
+      this.cacheStorage = await this.createCaches(options.caches);
+    }
+    if (this.workerPool) {
+      await this.workerPool.terminate();
+    }
+    const workerCount = options.workerCount || 1;
+    const poolOptions = {
+      workerCount,
+      requestTimeout: 3e4,
+      hotReload: this.options.hotReload,
+      cwd: this.options.cwd
+    };
+    this.workerPool = new WorkerPool(
+      this.cacheStorage,
+      poolOptions,
+      entryPath
+    );
+    await this.workerPool.init();
+    const version = Date.now();
+    await this.workerPool.reloadWorkers(version);
     const instance = {
-      runtime,
-      handleRequest: (request) => runtime.handleRequest(request),
-      install: () => runtime.install(),
-      activate: () => runtime.activate(),
-      collectStaticRoutes: (outDir, baseUrl) => runtime.collectStaticRoutes(outDir, baseUrl),
+      runtime: this.workerPool,
+      handleRequest: async (request) => {
+        if (!this.workerPool) {
+          throw new Error("WorkerPool not initialized");
+        }
+        return this.workerPool.handleRequest(request);
+      },
+      install: async () => {
+        console.info("[Bun] ServiceWorker installed via native Web Workers");
+      },
+      activate: async () => {
+        console.info("[Bun] ServiceWorker activated via native Web Workers");
+      },
+      collectStaticRoutes: async () => {
+        return [];
+      },
       get ready() {
-        return runtime.ready;
+        return this.workerPool?.ready ?? false;
       },
       dispose: async () => {
-        runtime.reset();
+        if (this.workerPool) {
+          await this.workerPool.terminate();
+          this.workerPool = void 0;
+        }
+        console.info("[Bun] ServiceWorker disposed");
       }
     };
-    if (this.options.hotReload && options.hotReload !== false) {
-      console.info("[Bun] Hot reloading enabled - native TypeScript support");
-      const loadModule = async () => {
-        try {
-          runtime.reset();
-          createServiceWorkerGlobals(runtime, { caches, dirs });
-          globalThis.self = runtime;
-          globalThis.addEventListener = runtime.addEventListener.bind(runtime);
-          globalThis.removeEventListener = runtime.removeEventListener.bind(runtime);
-          globalThis.dispatchEvent = runtime.dispatchEvent.bind(runtime);
-          const moduleUrl = `${entryPath}?t=${Date.now()}`;
-          await import(moduleUrl);
-          await runtime.install();
-          await runtime.activate();
-          console.info("[Bun] ServiceWorker loaded successfully");
-        } catch (error) {
-          console.error("[Bun] Failed to load ServiceWorker:", error);
-        }
-      };
-      await loadModule();
-    } else {
-      createServiceWorkerGlobals(runtime, { caches, dirs });
-      globalThis.self = runtime;
-      globalThis.addEventListener = runtime.addEventListener.bind(runtime);
-      globalThis.removeEventListener = runtime.removeEventListener.bind(runtime);
-      globalThis.dispatchEvent = runtime.dispatchEvent.bind(runtime);
-      await import(entryPath);
-      await runtime.install();
-      await runtime.activate();
-    }
     return instance;
   }
   /**
-   * Get filesystem root for File System Access API
+   * Reload workers for hot reloading (called by CLI)
    */
-  async getFileSystemRoot(name = "default") {
-    return await getFileSystemRoot(name);
+  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 createBunPlatform(options) {