@b9g/platform-bun 0.1.0

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@b9g/platform-bun",
+  "version": "0.1.0",
+  "description": "Bun platform adapter for Shovel with hot reloading and built-in TypeScript/JSX support",
+  "keywords": [
+    "shovel",
+    "platform",
+    "bun",
+    "adapter",
+    "hot-reload",
+    "typescript",
+    "jsx"
+  ],
+  "dependencies": {
+    "@b9g/platform": "workspace:*",
+    "@b9g/cache": "workspace:*",
+    "@b9g/assets": "workspace:*"
+  },
+  "devDependencies": {
+    "@b9g/libuild": "^0.1.10",
+    "bun-types": "latest"
+  },
+  "type": "module",
+  "types": "src/index.d.ts",
+  "module": "src/index.js",
+  "exports": {
+    ".": {
+      "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",
+      "import": "./src/index.js"
+    },
+    "./index.js": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    }
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @b9g/platform-bun - Bun platform adapter for Shovel
+ *
+ * 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";

package/src/index.js

@@ -0,0 +1,10 @@
+/// <reference types="./index.d.ts" />
+// src/index.ts
+import {
+  BunPlatform,
+  createBunPlatform
+} from "./platform.js";
+export {
+  BunPlatform,
+  createBunPlatform
+};

package/src/platform.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 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 _dist?;
+    constructor(options?: BunPlatformOptions);
+    /**
+     * Build artifacts filesystem (install-time only)
+     */
+    get distDir(): FileSystemDirectoryHandle;
+    /**
+     * Get platform-specific default cache configuration for Bun
+     */
+    protected getDefaultCacheConfig(): CacheConfig;
+    /**
+     * Override cache creation to use PostMessage coordination 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
+     */
+    loadServiceWorker(entrypoint: string, options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
+    /**
+     * Get filesystem root for File System Access API
+     */
+    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    /**
+     * 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

@@ -0,0 +1,170 @@
+/// <reference types="./platform.d.ts" />
+// src/platform.ts
+import {
+  BasePlatform,
+  ServiceWorkerRuntime,
+  createServiceWorkerGlobals,
+  createDirectoryStorage
+} from "@b9g/platform";
+import { CustomCacheStorage, PostMessageCache } from "@b9g/cache";
+import { FileSystemRegistry, getFileSystemRoot, MemoryFileSystemAdapter, NodeFileSystemAdapter, BunS3FileSystemAdapter } from "@b9g/filesystem";
+import * as Path from "path";
+var BunPlatform = class extends BasePlatform {
+  name = "bun";
+  options;
+  _dist;
+  constructor(options = {}) {
+    super(options);
+    this.options = {
+      hotReload: Bun.env.NODE_ENV !== "production",
+      port: 3e3,
+      host: "localhost",
+      cwd: process.cwd(),
+      ...options
+    };
+    FileSystemRegistry.register("memory", new MemoryFileSystemAdapter());
+    FileSystemRegistry.register("node", new NodeFileSystemAdapter({
+      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)
+   */
+  get distDir() {
+    if (!this._dist) {
+      const distPath = Path.resolve(this.options.cwd, "dist");
+      this._dist = new NodeFileSystemAdapter({ rootPath: distPath }).getFileSystemRoot("");
+    }
+    return this._dist;
+  }
+  /**
+   * 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 PostMessage coordination for Bun
+   */
+  async createCaches(config) {
+    return new CustomCacheStorage((name) => {
+      return new PostMessageCache(name, {
+        maxEntries: 1e3,
+        maxSize: 50 * 1024 * 1024
+        // 50MB
+      });
+    });
+  }
+  /**
+   * 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 {
+      listen: () => {
+        console.info(`\u{1F956} Bun server running at http://${hostname}:${port}`);
+        return Promise.resolve();
+      },
+      close: () => {
+        server.stop();
+        return Promise.resolve();
+      },
+      address: () => ({ port, host: hostname })
+    };
+  }
+  /**
+   * Load and run a ServiceWorker-style entrypoint with Bun
+   */
+  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);
+    const instance = {
+      runtime,
+      handleRequest: (request) => runtime.handleRequest(request),
+      install: () => runtime.install(),
+      activate: () => runtime.activate(),
+      collectStaticRoutes: (outDir, baseUrl) => runtime.collectStaticRoutes(outDir, baseUrl),
+      get ready() {
+        return runtime.ready;
+      },
+      dispose: async () => {
+        runtime.reset();
+      }
+    };
+    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
+   */
+  async getFileSystemRoot(name = "default") {
+    return await getFileSystemRoot(name);
+  }
+  /**
+   * Dispose of platform resources
+   */
+  async dispose() {
+  }
+};
+function createBunPlatform(options) {
+  return new BunPlatform(options);
+}
+var platform_default = createBunPlatform;
+export {
+  BunPlatform,
+  createBunPlatform,
+  platform_default as default
+};