@b9g/platform-bun 0.1.4 → 0.1.6

package/README.md

@@ -0,0 +1,84 @@
+# @b9g/platform-bun
+
+Bun platform adapter for Shovel. Runs ServiceWorker applications on Bun with native HTTP server integration and fast hot reloading.
+
+## Features
+
+- Bun HTTP server integration
+- Fast hot module reloading
+- Worker thread support for concurrency
+- Memory and filesystem cache backends
+- File System Access API implementation via BunBucket
+
+## Installation
+
+```bash
+bun install @b9g/platform-bun
+```
+
+## Usage
+
+```javascript
+import BunPlatform from '@b9g/platform-bun';
+
+const platform = new BunPlatform({
+  cache: { type: 'memory' },
+  filesystem: { type: 'local', directory: './dist' }
+});
+
+const server = platform.createServer(async (request) => {
+  return new Response('Hello from Bun');
+}, { port: 3000, host: 'localhost' });
+
+await server.listen();
+```
+
+## Exports
+
+### Classes
+
+- `BunPlatform` - Bun platform implementation (extends BasePlatform)
+
+### Types
+
+- `BunPlatformOptions` - Configuration options for BunPlatform
+
+### Re-exports from @b9g/platform
+
+- `Platform`, `CacheConfig`, `StaticConfig`, `Handler`, `Server`, `ServerOptions`
+
+### Default Export
+
+- `BunPlatform` - The platform class
+
+## API
+
+### `new BunPlatform(options?)`
+
+Creates a new Bun platform instance.
+
+**Options:**
+- `cache`: Cache configuration (memory, filesystem)
+- `filesystem`: Filesystem configuration (local directory)
+- `port`: Default port (default: 3000)
+- `host`: Default host (default: localhost)
+- `cwd`: Working directory for file resolution
+
+### `platform.createServer(handler, options)`
+
+Creates a Bun HTTP server with the given request handler.
+
+**Options:**
+- `port`: Port to listen on
+- `host`: Host to bind to
+
+Returns a Server instance with `listen()` and `close()` methods.
+
+## Cache Backends
+
+- `memory`: In-memory caching using MemoryCache
+- `filesystem`: Filesystem-based caching using BunBucket
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-bun",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Bun platform adapter for Shovel with hot reloading and built-in TypeScript/JSX support",
   "keywords": [
     "shovel",
@@ -12,9 +12,8 @@
     "jsx"
   ],
   "dependencies": {
-    "@b9g/platform": "^0.1.4",
-    "@b9g/cache": "^0.1.3",
-    "@b9g/assets": "^0.1.4"
+    "@b9g/platform": "^0.1.6",
+    "@b9g/assets": "^0.1.6"
   },
   "devDependencies": {
     "@b9g/libuild": "^0.1.11",
@@ -28,14 +27,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 built-in TypeScript/JSX support and simplified server setup for Bun environments.
  */
-export { BunPlatform, createBunPlatform, type BunPlatformOptions, } from "./platform.js";
-export type { Platform, CacheConfig, StaticConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance, } 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, ServiceWorkerOptions, ServiceWorkerInstance, } from "@b9g/platform";
+export interface BunPlatformOptions 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;
+}
+/**
+ * Bun platform implementation
+ * ServiceWorker entrypoint loader for Bun with native TypeScript/JSX support
+ */
+export declare class BunPlatform extends BasePlatform {
+    #private;
+    readonly name: string;
+    constructor(options?: BunPlatformOptions);
+    /**
+     * Get options for testing
+     */
+    get options(): Required<BunPlatformOptions>;
+    /**
+     * Get/set worker pool for testing
+     */
+    get workerPool(): ServiceWorkerPool | undefined;
+    set workerPool(pool: ServiceWorkerPool | undefined);
+    /**
+     * Create cache storage
+     * Uses config from package.json shovel field
+     */
+    createCaches(): Promise<CustomCacheStorage>;
+    /**
+     * Create HTTP server using Bun.serve
+     */
+    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
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Default export for easy importing
+ */
+export default BunPlatform;

package/src/index.js

@@ -1,10 +1,247 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
 import {
-  BunPlatform,
-  createBunPlatform
-} from "./platform.js";
+  BasePlatform,
+  ServiceWorkerPool,
+  SingleThreadedRuntime,
+  loadConfig,
+  createCacheFactory
+} from "@b9g/platform";
+import { CustomCacheStorage } from "@b9g/cache";
+import * as Path from "path";
+import { getLogger } from "@logtape/logtape";
+var logger = getLogger(["platform-bun"]);
+var BunPlatform = class extends BasePlatform {
+  name;
+  #options;
+  #workerPool;
+  #singleThreadedRuntime;
+  #cacheStorage;
+  #config;
+  constructor(options = {}) {
+    super(options);
+    this.name = "bun";
+    const cwd = options.cwd || process.cwd();
+    this.#config = loadConfig(cwd);
+    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;
+  }
+  /**
+   * Create cache storage
+   * Uses config from package.json shovel field
+   */
+  async createCaches() {
+    return new CustomCacheStorage(createCacheFactory({ config: this.#config }));
+  }
+  /**
+   * Create HTTP server using Bun.serve
+   */
+  createServer(handler, options = {}) {
+    const port = options.port ?? this.#options.port;
+    const hostname = options.host ?? this.#options.host;
+    const server = Bun.serve({
+      port,
+      hostname,
+      async fetch(request) {
+        return handler(request);
+      }
+    });
+    return {
+      async listen() {
+        logger.info("Bun server running", { url: `http://${hostname}:${port}` });
+      },
+      async close() {
+        server.stop();
+      },
+      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 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();
+    }
+    const poolOptions = {
+      workerCount,
+      requestTimeout: 3e4,
+      cwd: this.#options.cwd
+    };
+    logger.info("Creating ServiceWorker pool", { entryPath, workerCount });
+    this.#workerPool = new ServiceWorkerPool(
+      poolOptions,
+      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("WorkerPool not initialized");
+        }
+        return platform.#workerPool.handleRequest(request);
+      },
+      install: async () => {
+        logger.info("ServiceWorker installed", { method: "native_web_workers" });
+      },
+      activate: async () => {
+        logger.info("ServiceWorker activated", { method: "native_web_workers" });
+      },
+      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: ["native_web_workers", "coordinated_caches"]
+    });
+    return instance;
+  }
+  /**
+   * 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 = BunPlatform;
 export {
   BunPlatform,
-  createBunPlatform
+  src_default as default
 };

package/src/platform.d.ts

@@ -1,66 +0,0 @@
-/**
- * Bun platform implementation - ServiceWorker entrypoint loader for Bun
- *
- * Bun has built-in TypeScript/JSX support, so this is much simpler than Node.js.
- * Uses native imports instead of complex ESBuild VM system.
- */
-import { BasePlatform, PlatformConfig, CacheConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance } from "@b9g/platform";
-import { CustomCacheStorage } from "@b9g/cache";
-export interface BunPlatformOptions 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;
-}
-/**
- * Bun platform implementation
- * ServiceWorker entrypoint loader for Bun with native TypeScript/JSX support
- */
-export declare class BunPlatform extends BasePlatform {
-    readonly name = "bun";
-    private options;
-    private workerPool?;
-    private cacheStorage?;
-    constructor(options?: BunPlatformOptions);
-    /**
-     * Build artifacts filesystem (install-time only)
-     */
-    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * Get platform-specific default cache configuration for Bun
-     */
-    protected getDefaultCacheConfig(): CacheConfig;
-    /**
-     * Override cache creation to use appropriate cache type for Bun
-     */
-    createCaches(config?: CacheConfig): Promise<CustomCacheStorage>;
-    /**
-     * Create HTTP server using Bun.serve
-     */
-    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
-     */
-    dispose(): Promise<void>;
-}
-/**
- * Create a Bun platform instance
- */
-export declare function createBunPlatform(options?: BunPlatformOptions): BunPlatform;
-/**
- * Default export for easy importing
- */
-export default createBunPlatform;

package/src/platform.js

@@ -1,191 +0,0 @@
-/// <reference types="./platform.d.ts" />
-// src/platform.ts
-import {
-  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 = {
-      hotReload: Bun.env.NODE_ENV !== "production",
-      port: 3e3,
-      host: "localhost",
-      cwd: process.cwd(),
-      ...options
-    };
-    FileSystemRegistry.register("memory", new MemoryBucket());
-    FileSystemRegistry.register("node", new LocalBucket({
-      rootPath: Path.join(this.options.cwd, "dist")
-    }));
-    try {
-      FileSystemRegistry.register("bun-s3", new BunS3FileSystemAdapter(
-        // @ts-ignore - Bun's S3Client
-        new Bun.S3Client({})
-      ));
-    } catch {
-      console.warn("[Bun] S3Client not available, using memory filesystem");
-    }
-  }
-  /**
-   * Build artifacts filesystem (install-time only)
-   */
-  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
-   */
-  getDefaultCacheConfig() {
-    return {
-      pages: { type: "memory" },
-      // PostMessage cache for coordination
-      api: { type: "memory" },
-      static: { type: "memory" }
-    };
-  }
-  /**
-   * 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) => {
-      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
-        });
-      }
-    });
-  }
-  /**
-   * Create HTTP server using Bun.serve
-   */
-  createServer(handler, options = {}) {
-    const port = options.port ?? this.options.port;
-    const hostname = options.host ?? this.options.host;
-    const server = Bun.serve({
-      port,
-      hostname,
-      async fetch(request) {
-        return handler(request);
-      },
-      development: this.options.hotReload
-    });
-    return {
-      async listen() {
-        console.info(`\u{1F956} Bun server running at http://${hostname}:${port}`);
-      },
-      async close() {
-        server.stop();
-      },
-      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 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;
-    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: 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 this.workerPool?.ready ?? false;
-      },
-      dispose: async () => {
-        if (this.workerPool) {
-          await this.workerPool.terminate();
-          this.workerPool = void 0;
-        }
-        console.info("[Bun] ServiceWorker disposed");
-      }
-    };
-    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) {
-  return new BunPlatform(options);
-}
-var platform_default = createBunPlatform;
-export {
-  BunPlatform,
-  createBunPlatform,
-  platform_default as default
-};