@b9g/platform-bun 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.2",
+  "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,6 +23,8 @@ export interface BunPlatformOptions extends PlatformConfig {
 export declare class BunPlatform extends BasePlatform {
     readonly name = "bun";
     private options;
+    private workerPool?;
+    private cacheStorage?;
     constructor(options?: BunPlatformOptions);
     /**
      * Build artifacts filesystem (install-time only)
@@ -42,8 +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>;
+    /**
+     * Reload workers for hot reloading (called by CLI)
+     */
+    reloadWorkers(version?: number | string): Promise<void>;
     /**
      * Dispose of platform resources
      */

package/src/platform.js

@@ -1,17 +1,17 @@
 /// <reference types="./platform.d.ts" />
 // src/platform.ts
 import {
-  BasePlatform,
-  ServiceWorkerRuntime,
-  createServiceWorkerGlobals,
-  createBucketStorage
+  BasePlatform
 } from "@b9g/platform";
+import { WorkerPool } from "@b9g/platform/worker-pool";
 import { CustomCacheStorage, PostMessageCache } from "@b9g/cache";
 import { FileSystemRegistry, MemoryBucket, LocalBucket } from "@b9g/filesystem";
 import * as Path from "path";
 var BunPlatform = class extends BasePlatform {
   name = "bun";
   options;
+  workerPool;
+  cacheStorage;
   constructor(options = {}) {
     super(options);
     this.options = {
@@ -58,19 +58,19 @@ var BunPlatform = class extends BasePlatform {
    */
   async createCaches(config) {
     const { MemoryCache } = await import("@b9g/cache");
-    const { isMainThread } = await import("worker_threads");
+    const isWorkerThread = typeof self !== "undefined" && typeof window === "undefined";
     return new CustomCacheStorage((name) => {
-      if (isMainThread) {
+      if (!isWorkerThread) {
         return new MemoryCache(name, {
           maxEntries: 1e3,
-          maxSize: 50 * 1024 * 1024
-          // 50MB
+          maxAge: 60 * 60 * 1e3
+          // 1 hour
         });
       } else {
         return new PostMessageCache(name, {
           maxEntries: 1e3,
-          maxSize: 50 * 1024 * 1024
-          // 50MB
+          maxAge: 60 * 60 * 1e3
+          // 1 hour
         });
       }
     });
@@ -107,62 +107,77 @@ var BunPlatform = class extends BasePlatform {
   }
   /**
    * 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 distPath = Path.resolve(this.options.cwd, "dist");
-    const buckets = createBucketStorage(distPath);
+    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, buckets });
-          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, buckets });
-      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;
   }
+  /**
+   * 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 createBunPlatform(options) {