@b9g/platform 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Base Platform interface and types for Shovel deployment adapters",
   "keywords": [
     "shovel",
@@ -13,7 +13,7 @@
     "@types/wicg-file-system-access": "^2023.10.7"
   },
   "devDependencies": {
-    "@b9g/libuild": "^0.1.10",
+    "@b9g/libuild": "^0.1.11",
     "bun-types": "latest"
   },
   "type": "module",
@@ -104,6 +104,22 @@
     "./directory-storage.js": {
       "types": "./src/directory-storage.d.ts",
       "import": "./src/directory-storage.js"
+    },
+    "./worker-pool": {
+      "types": "./src/worker-pool.d.ts",
+      "import": "./src/worker-pool.js"
+    },
+    "./worker-pool.js": {
+      "types": "./src/worker-pool.d.ts",
+      "import": "./src/worker-pool.js"
+    },
+    "./worker-web": {
+      "types": "./src/undefined.d.ts",
+      "import": "./src/worker-web.js"
+    },
+    "./worker-web.js": {
+      "types": "./src/undefined.d.ts",
+      "import": "./src/worker-web.js"
     }
   }
 }

package/src/directory-storage.d.ts

@@ -30,6 +30,10 @@ export declare class PlatformBucketStorage implements BucketStorageInterface {
      * List all available bucket names
      */
     keys(): Promise<string[]>;
+    /**
+     * Alias for open() - for compatibility with File System Access API naming
+     */
+    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
 }
 /**
  * Create a BucketStorage instance from a root path

package/src/directory-storage.js

@@ -37,6 +37,12 @@ var PlatformBucketStorage = class {
   async keys() {
     return await this.buckets.keys();
   }
+  /**
+   * Alias for open() - for compatibility with File System Access API naming
+   */
+  async getDirectoryHandle(name) {
+    return await this.open(name);
+  }
 };
 function createBucketStorage(rootPath = "./dist") {
   return new PlatformBucketStorage(rootPath);

package/src/index.d.ts

@@ -12,3 +12,4 @@ export { platformRegistry, detectPlatform, getPlatform, getPlatformAsync, } from
 export { detectRuntime, detectDevelopmentPlatform, detectPlatforms, getBestPlatformDetection, resolvePlatform, createPlatform, displayPlatformInfo, } from "./detection.js";
 export { parseTTL, mergeCacheConfig, validateCacheConfig, createCorsHeaders, mergeHeaders, isPreflightRequest, createPreflightResponse, } from "./utils.js";
 export { getDirectoryHandle, getBucket, getFileSystemRoot } from "./filesystem.js";
+export { WorkerPool, type WorkerFactory, type PlatformWorker, type WorkerPoolOptions } from "./worker-pool.js";

package/src/index.js

@@ -34,10 +34,12 @@ import {
   createPreflightResponse
 } from "./utils.js";
 import { getDirectoryHandle, getBucket, getFileSystemRoot } from "./filesystem.js";
+import { WorkerPool } from "./worker-pool.js";
 export {
   BasePlatform,
   PlatformBucketStorage,
   ServiceWorkerRuntime,
+  WorkerPool,
   createBucketStorage,
   createCorsHeaders,
   createPlatform,

package/src/service-worker.d.ts

@@ -3,39 +3,56 @@
  *
  * Provides ServiceWorker APIs (self, addEventListener, etc.) in any JavaScript runtime
  */
+/**
+ * ExtendableEvent base class following ServiceWorker spec
+ */
+export declare class ExtendableEvent extends Event {
+    private promises;
+    private pendingPromises;
+    constructor(type: string, pendingPromises: Set<Promise<any>>);
+    waitUntil(promise: Promise<any>): void;
+    getPromises(): Promise<any>[];
+}
 /**
  * ServiceWorker-style fetch event
  */
-export interface ShovelFetchEvent extends Event {
-    readonly type: "fetch";
+export declare class FetchEvent extends ExtendableEvent {
     readonly request: Request;
+    private responsePromise;
+    private responded;
+    constructor(request: Request, pendingPromises: Set<Promise<any>>);
     respondWith(response: Response | Promise<Response>): void;
-    waitUntil(promise: Promise<any>): void;
+    getResponse(): Promise<Response> | null;
+    hasResponded(): boolean;
 }
 /**
  * ServiceWorker-style install event
  */
-export interface ShovelInstallEvent extends Event {
-    readonly type: "install";
-    waitUntil(promise: Promise<any>): void;
+export declare class InstallEvent extends ExtendableEvent {
+    constructor(pendingPromises: Set<Promise<any>>);
 }
 /**
  * ServiceWorker-style activate event
  */
-export interface ShovelActivateEvent extends Event {
-    readonly type: "activate";
-    waitUntil(promise: Promise<any>): void;
+export declare class ActivateEvent extends ExtendableEvent {
+    constructor(pendingPromises: Set<Promise<any>>);
 }
 /**
- * Static generation event for collecting routes
+ * Legacy interfaces for backward compatibility
  */
-export interface ShovelStaticEvent extends Event {
-    readonly type: "static";
-    readonly detail: {
-        outDir: string;
-        baseUrl?: string;
-    };
-    waitUntil(promise: Promise<string[]>): void;
+export interface ShovelFetchEvent extends Event {
+    readonly type: "fetch";
+    readonly request: Request;
+    respondWith(response: Response | Promise<Response>): void;
+    waitUntil(promise: Promise<any>): void;
+}
+export interface ShovelInstallEvent extends Event {
+    readonly type: "install";
+    waitUntil(promise: Promise<any>): void;
+}
+export interface ShovelActivateEvent extends Event {
+    readonly type: "activate";
+    waitUntil(promise: Promise<any>): void;
 }
 /**
  * ServiceWorker runtime that can be embedded in any platform
@@ -44,7 +61,10 @@ export declare class ServiceWorkerRuntime extends EventTarget {
     private pendingPromises;
     private isInstalled;
     private isActivated;
+    private eventListeners;
     constructor();
+    addEventListener(type: string, listener: Function): void;
+    removeEventListener(type: string, listener: Function): void;
     /**
      * Create a fetch event and dispatch it
      */
@@ -57,10 +77,6 @@ export declare class ServiceWorkerRuntime extends EventTarget {
      * Activate the ServiceWorker
      */
     activate(): Promise<void>;
-    /**
-     * Collect static routes for pre-rendering
-     */
-    collectStaticRoutes(outDir: string, baseUrl?: string): Promise<string[]>;
     /**
      * Check if ready to handle requests
      */
@@ -84,6 +100,10 @@ export interface BucketStorage {
      * Well-known names: 'assets', 'static', 'uploads', 'temp'
      */
     open(name: string): Promise<FileSystemDirectoryHandle>;
+    /**
+     * Alias for open() - for compatibility with File System Access API naming
+     */
+    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
     /**
      * Check if a named bucket exists
      */
@@ -103,16 +123,9 @@ export interface BucketStorage {
 export declare function createServiceWorkerGlobals(runtime: ServiceWorkerRuntime, options?: {
     caches?: any;
     buckets?: BucketStorage;
+    isDevelopment?: boolean;
+    hotReload?: () => Promise<void>;
 }): {
-    self: ServiceWorkerRuntime;
-    addEventListener: any;
-    removeEventListener: any;
-    dispatchEvent: any;
-    skipWaiting: () => Promise<void>;
-    clients: {
-        claim: () => Promise<void>;
-        matchAll: () => Promise<any[]>;
-    };
     console: Console;
     setTimeout: typeof setTimeout;
     clearTimeout: typeof clearTimeout;
@@ -146,4 +159,17 @@ export declare function createServiceWorkerGlobals(runtime: ServiceWorkerRuntime
         new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
         prototype: URLSearchParams;
     };
+    caches: any;
+    buckets: BucketStorage;
+    self: ServiceWorkerRuntime;
+    addEventListener: any;
+    removeEventListener: any;
+    dispatchEvent: any;
+    skipWaiting: () => Promise<void>;
+    clients: {
+        claim(): Promise<void>;
+        get(id: string): Promise<any>;
+        matchAll(options?: any): Promise<any[]>;
+        openWindow(url: string | URL): Promise<any>;
+    };
 };

package/src/service-worker.js

@@ -1,12 +1,81 @@
 /// <reference types="./service-worker.d.ts" />
 // src/service-worker.ts
+var ExtendableEvent = class extends Event {
+  promises = [];
+  pendingPromises;
+  constructor(type, pendingPromises) {
+    super(type);
+    this.pendingPromises = pendingPromises;
+  }
+  waitUntil(promise) {
+    this.promises.push(promise);
+    this.pendingPromises.add(promise);
+    promise.finally(() => this.pendingPromises.delete(promise));
+  }
+  getPromises() {
+    return [...this.promises];
+  }
+};
+var FetchEvent = class extends ExtendableEvent {
+  request;
+  responsePromise = null;
+  responded = false;
+  constructor(request, pendingPromises) {
+    super("fetch", pendingPromises);
+    this.request = request;
+  }
+  respondWith(response) {
+    if (this.responded) {
+      throw new Error("respondWith() already called");
+    }
+    this.responded = true;
+    this.responsePromise = Promise.resolve(response);
+  }
+  getResponse() {
+    return this.responsePromise;
+  }
+  hasResponded() {
+    return this.responded;
+  }
+};
+var InstallEvent = class extends ExtendableEvent {
+  constructor(pendingPromises) {
+    super("install", pendingPromises);
+  }
+};
+var ActivateEvent = class extends ExtendableEvent {
+  constructor(pendingPromises) {
+    super("activate", pendingPromises);
+  }
+};
 var ServiceWorkerRuntime = class extends EventTarget {
   pendingPromises = /* @__PURE__ */ new Set();
   isInstalled = false;
   isActivated = false;
+  eventListeners = /* @__PURE__ */ new Map();
   constructor() {
     super();
   }
+  addEventListener(type, listener) {
+    super.addEventListener(type, listener);
+    if (!this.eventListeners.has(type)) {
+      this.eventListeners.set(type, []);
+    }
+    this.eventListeners.get(type).push(listener);
+  }
+  removeEventListener(type, listener) {
+    super.removeEventListener(type, listener);
+    if (this.eventListeners.has(type)) {
+      const listeners = this.eventListeners.get(type);
+      const index = listeners.indexOf(listener);
+      if (index > -1) {
+        listeners.splice(index, 1);
+        if (listeners.length === 0) {
+          this.eventListeners.delete(type);
+        }
+      }
+    }
+  }
   /**
    * Create a fetch event and dispatch it
    */
@@ -15,28 +84,22 @@ var ServiceWorkerRuntime = class extends EventTarget {
       throw new Error("ServiceWorker not activated");
     }
     return new Promise((resolve, reject) => {
-      let responded = false;
-      const promises = [];
-      const event = Object.assign(new Event("fetch"), {
-        request,
-        respondWith: (response) => {
-          if (responded) {
-            throw new Error("respondWith() already called");
-          }
-          responded = true;
-          Promise.resolve(response).then(resolve).catch(reject);
-        },
-        waitUntil: (promise) => {
-          promises.push(promise);
-          this.pendingPromises.add(promise);
-          promise.finally(() => this.pendingPromises.delete(promise));
+      const event = new FetchEvent(request, this.pendingPromises);
+      process.nextTick(() => {
+        this.dispatchEvent(event);
+        const promises = event.getPromises();
+        if (promises.length > 0) {
+          Promise.allSettled(promises).catch(console.error);
         }
       });
-      this.dispatchEvent(event);
-      if (!responded) {
-        reject(new Error("No response provided for fetch event"));
-      }
-      Promise.allSettled(promises).catch(console.error);
+      setTimeout(() => {
+        if (event.hasResponded()) {
+          const responsePromise = event.getResponse();
+          responsePromise.then(resolve).catch(reject);
+        } else {
+          reject(new Error("No response provided for fetch event"));
+        }
+      }, 0);
     });
   }
   /**
@@ -46,22 +109,20 @@ var ServiceWorkerRuntime = class extends EventTarget {
     if (this.isInstalled)
       return;
     return new Promise((resolve, reject) => {
-      const promises = [];
-      let installCancelled = false;
-      const event = Object.assign(new Event("install"), {
-        waitUntil: (promise) => {
-          promises.push(promise);
-          this.pendingPromises.add(promise);
-          promise.finally(() => this.pendingPromises.delete(promise));
-        }
-      });
-      this.dispatchEvent(event);
-      Promise.allSettled(promises).then(() => {
-        if (!installCancelled) {
+      const event = new InstallEvent(this.pendingPromises);
+      process.nextTick(() => {
+        this.dispatchEvent(event);
+        const promises = event.getPromises();
+        if (promises.length === 0) {
           this.isInstalled = true;
           resolve();
+        } else {
+          Promise.all(promises).then(() => {
+            this.isInstalled = true;
+            resolve();
+          }).catch(reject);
         }
-      }).catch(reject);
+      });
     });
   }
   /**
@@ -74,46 +135,20 @@ var ServiceWorkerRuntime = class extends EventTarget {
     if (this.isActivated)
       return;
     return new Promise((resolve, reject) => {
-      const promises = [];
-      const event = Object.assign(new Event("activate"), {
-        waitUntil: (promise) => {
-          promises.push(promise);
-          this.pendingPromises.add(promise);
-          promise.finally(() => this.pendingPromises.delete(promise));
-        }
-      });
-      this.dispatchEvent(event);
-      Promise.allSettled(promises).then(() => {
-        this.isActivated = true;
-        resolve();
-      }).catch(reject);
-    });
-  }
-  /**
-   * Collect static routes for pre-rendering
-   */
-  async collectStaticRoutes(outDir, baseUrl) {
-    return new Promise((resolve, reject) => {
-      let routes = [];
-      const promises = [];
-      const event = Object.assign(new Event("static"), {
-        detail: { outDir, baseUrl },
-        waitUntil: (promise) => {
-          promises.push(
-            promise.then((routeList) => {
-              routes = routes.concat(routeList);
-            })
-          );
-          this.pendingPromises.add(promise);
-          promise.finally(() => this.pendingPromises.delete(promise));
+      const event = new ActivateEvent(this.pendingPromises);
+      process.nextTick(() => {
+        this.dispatchEvent(event);
+        const promises = event.getPromises();
+        if (promises.length === 0) {
+          this.isActivated = true;
+          resolve();
+        } else {
+          Promise.all(promises).then(() => {
+            this.isActivated = true;
+            resolve();
+          }).catch(reject);
         }
       });
-      this.dispatchEvent(event);
-      if (promises.length === 0) {
-        resolve([]);
-      } else {
-        Promise.allSettled(promises).then(() => resolve([...new Set(routes)])).catch(reject);
-      }
     });
   }
   /**
@@ -137,12 +172,12 @@ var ServiceWorkerRuntime = class extends EventTarget {
     this.isInstalled = false;
     this.isActivated = false;
     this.pendingPromises.clear();
-    const listeners = this._listeners;
-    if (listeners) {
-      for (const type in listeners) {
-        delete listeners[type];
+    for (const [type, listeners] of this.eventListeners) {
+      for (const listener of listeners) {
+        super.removeEventListener(type, listener);
       }
     }
+    this.eventListeners.clear();
   }
 };
 function createServiceWorkerGlobals(runtime, options = {}) {
@@ -152,17 +187,38 @@ function createServiceWorkerGlobals(runtime, options = {}) {
   if (options.buckets) {
     runtime.buckets = options.buckets;
   }
-  return {
+  const skipWaiting = async () => {
+    if (options.isDevelopment && options.hotReload) {
+      console.info("[ServiceWorker] skipWaiting() - triggering hot reload");
+      await options.hotReload();
+    } else if (!options.isDevelopment) {
+      console.info("[ServiceWorker] skipWaiting() - production graceful restart not implemented");
+    }
+  };
+  const clients = {
+    async claim() {
+    },
+    async get(id) {
+      return void 0;
+    },
+    async matchAll(options2) {
+      return [];
+    },
+    async openWindow(url) {
+      return null;
+    }
+  };
+  const globals = {
     self: runtime,
     addEventListener: runtime.addEventListener.bind(runtime),
     removeEventListener: runtime.removeEventListener.bind(runtime),
     dispatchEvent: runtime.dispatchEvent.bind(runtime),
-    // ServiceWorker-specific globals that might be useful
-    skipWaiting: () => Promise.resolve(),
-    clients: {
-      claim: () => Promise.resolve(),
-      matchAll: () => Promise.resolve([])
-    },
+    // ServiceWorker-specific globals with proper implementations
+    skipWaiting,
+    clients,
+    // Platform resources
+    ...options.buckets && { buckets: options.buckets },
+    ...options.caches && { caches: options.caches },
     // Standard globals
     console,
     setTimeout,
@@ -176,8 +232,14 @@ function createServiceWorkerGlobals(runtime, options = {}) {
     URL,
     URLSearchParams
   };
+  Object.assign(globalThis, globals);
+  return globals;
 }
 export {
+  ActivateEvent,
+  ExtendableEvent,
+  FetchEvent,
+  InstallEvent,
   ServiceWorkerRuntime,
   createServiceWorkerGlobals
 };

package/src/worker-pool.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Common WorkerPool abstraction based on web standards
+ * Provides platform-agnostic worker management for ServiceWorker execution
+ */
+import { CustomCacheStorage } from "@b9g/cache";
+export interface WorkerPoolOptions {
+    /** Number of workers in the pool (default: 1) */
+    workerCount?: number;
+    /** Request timeout in milliseconds (default: 30000) */
+    requestTimeout?: number;
+    /** Enable hot reloading (default: true in development) */
+    hotReload?: boolean;
+    /** Working directory for file resolution */
+    cwd?: string;
+}
+export interface WorkerMessage {
+    type: string;
+    [key: string]: any;
+}
+export interface WorkerRequest extends WorkerMessage {
+    type: "request";
+    request: {
+        url: string;
+        method: string;
+        headers: Record<string, string>;
+        body?: any;
+    };
+    requestId: number;
+}
+export interface WorkerResponse extends WorkerMessage {
+    type: "response";
+    response: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string>;
+        body: string;
+    };
+    requestId: number;
+}
+export interface WorkerLoadMessage extends WorkerMessage {
+    type: "load";
+    version: number | string;
+    entrypoint?: string;
+}
+export interface WorkerReadyMessage extends WorkerMessage {
+    type: "ready" | "worker-ready";
+    version?: number | string;
+}
+export interface WorkerErrorMessage extends WorkerMessage {
+    type: "error";
+    error: string;
+    stack?: string;
+    requestId?: number;
+}
+/**
+ * Common WorkerPool implementation based on web standards
+ * Provides round-robin request handling, hot reloading, and cache coordination
+ */
+export declare class WorkerPool {
+    private workers;
+    private currentWorker;
+    private requestId;
+    private pendingRequests;
+    private options;
+    private cacheStorage;
+    private appEntrypoint?;
+    constructor(cacheStorage: CustomCacheStorage, options?: WorkerPoolOptions, appEntrypoint?: string);
+    /**
+     * Initialize workers (must be called after construction)
+     */
+    init(): Promise<void>;
+    private initWorkers;
+    private createWorker;
+    private handleWorkerMessage;
+    private handleResponse;
+    private handleError;
+    private handleReady;
+    /**
+     * Platform-specific cache message handling
+     * Override this method in platform implementations for custom cache coordination
+     */
+    protected handleCacheMessage(message: WorkerMessage): void;
+    /**
+     * Handle HTTP request using round-robin worker selection
+     */
+    handleRequest(request: Request): Promise<Response>;
+    /**
+     * Reload ServiceWorker with new version (hot reload simulation)
+     */
+    reloadWorkers(version?: number | string): Promise<void>;
+    /**
+     * Graceful shutdown of all workers
+     */
+    terminate(): Promise<void>;
+    /**
+     * Get the number of active workers
+     */
+    get workerCount(): number;
+    /**
+     * Check if the pool is ready to handle requests
+     */
+    get ready(): boolean;
+}

package/src/worker-pool.js

@@ -0,0 +1,271 @@
+/// <reference types="./worker-pool.d.ts" />
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/worker-pool.ts
+import * as Path from "path";
+function resolveWorkerScript(entrypoint) {
+  if (entrypoint) {
+    const entryDir = Path.dirname(entrypoint);
+    const bundledWorker = Path.join(entryDir, "worker.js");
+    try {
+      if (typeof Bun !== "undefined") {
+        const file = Bun.file(bundledWorker);
+        if (file.size > 0) {
+          console.debug(`[WorkerPool] Using bundled worker: ${bundledWorker}`);
+          return bundledWorker;
+        }
+      } else if (typeof __require !== "undefined") {
+        const fs = __require("fs");
+        if (fs.existsSync(bundledWorker)) {
+          console.debug(`[WorkerPool] Using bundled worker: ${bundledWorker}`);
+          return bundledWorker;
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const workerUrl = import.meta.resolve("@b9g/platform/worker-web.js");
+    let workerScript;
+    if (workerUrl.startsWith("file://")) {
+      workerScript = workerUrl.slice(7);
+    } else {
+      workerScript = workerUrl;
+    }
+    console.debug(`[WorkerPool] Using Web Worker-compatible script: ${workerScript}`);
+    return workerScript;
+  } catch (error) {
+    const bundledPath = entrypoint ? Path.join(Path.dirname(entrypoint), "worker-web.js") : "worker-web.js";
+    throw new Error(
+      `Could not resolve worker-web.js. Checked bundled path: ${bundledPath} and package: @b9g/platform/worker-web.js. Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function createWebWorker(workerScript) {
+  if (typeof Worker !== "undefined") {
+    return new Worker(workerScript, { type: "module" });
+  }
+  const isNodeJs = typeof process !== "undefined" && process.versions?.node;
+  if (isNodeJs) {
+    try {
+      const { Worker: NodeWebWorker } = await import("@b9g/node-webworker");
+      console.debug("[WorkerPool] Using @b9g/node-webworker shim for Node.js");
+      return new NodeWebWorker(workerScript, { type: "module" });
+    } catch (shimError) {
+      console.error("\n\u274C MISSING WEB STANDARD: Node.js lacks native Web Worker support");
+      console.error("\u{1F517} CANONICAL ISSUE: https://github.com/nodejs/node/issues/43583");
+      console.error("\u{1F4AC} This is a basic web standard from 2009 - help push for implementation!");
+      console.error("\u{1F5F3}\uFE0F  Please \u{1F44D} react and comment on the issue to show demand\n");
+      throw new Error(`\u274C Web Worker not available on Node.js
+
+\u{1F517} Node.js doesn't implement the Web Worker standard yet.
+   CANONICAL ISSUE: https://github.com/nodejs/node/issues/43583
+   
+\u{1F5F3}\uFE0F  Please \u{1F44D} react and comment to show demand for this basic web standard!
+
+\u{1F4A1} Immediate workaround:
+   npm install @b9g/node-webworker
+   
+   This installs our minimal, reliable Web Worker shim for Node.js.
+
+\u{1F4DA} Learn more: https://developer.mozilla.org/en-US/docs/Web/API/Worker`);
+    }
+  }
+  const runtime = typeof Bun !== "undefined" ? "Bun" : typeof Deno !== "undefined" ? "Deno" : "Unknown";
+  throw new Error(`\u274C Web Worker not available on ${runtime}
+
+This runtime should support Web Workers but the API is not available.
+Please check your runtime version and configuration.
+
+\u{1F4DA} Web Worker standard: https://developer.mozilla.org/en-US/docs/Web/API/Worker`);
+}
+var WorkerPool = class {
+  workers = [];
+  currentWorker = 0;
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  options;
+  cacheStorage;
+  appEntrypoint;
+  constructor(cacheStorage, options = {}, appEntrypoint) {
+    this.cacheStorage = cacheStorage;
+    this.appEntrypoint = appEntrypoint;
+    this.options = {
+      workerCount: 1,
+      requestTimeout: 3e4,
+      hotReload: process.env.NODE_ENV !== "production",
+      cwd: process.cwd(),
+      ...options
+    };
+  }
+  /**
+   * Initialize workers (must be called after construction)
+   */
+  async init() {
+    await this.initWorkers();
+  }
+  async initWorkers() {
+    for (let i = 0; i < this.options.workerCount; i++) {
+      await this.createWorker();
+    }
+  }
+  async createWorker() {
+    const workerScript = resolveWorkerScript(this.appEntrypoint);
+    const worker = await createWebWorker(workerScript);
+    worker.addEventListener("message", (event) => {
+      this.handleWorkerMessage(event.data || event);
+    });
+    worker.addEventListener("error", (error) => {
+      console.error("[WorkerPool] Worker error:", error);
+    });
+    this.workers.push(worker);
+    return worker;
+  }
+  handleWorkerMessage(message) {
+    if (message.type?.startsWith("cache:")) {
+      this.handleCacheMessage(message);
+      return;
+    }
+    switch (message.type) {
+      case "response":
+        this.handleResponse(message);
+        break;
+      case "error":
+        this.handleError(message);
+        break;
+      case "ready":
+      case "worker-ready":
+        this.handleReady(message);
+        break;
+      default:
+        console.warn("[WorkerPool] Unknown message type:", message.type);
+    }
+  }
+  handleResponse(message) {
+    const pending = this.pendingRequests.get(message.requestId);
+    if (pending) {
+      const response = new Response(message.response.body, {
+        status: message.response.status,
+        statusText: message.response.statusText,
+        headers: message.response.headers
+      });
+      pending.resolve(response);
+      this.pendingRequests.delete(message.requestId);
+    }
+  }
+  handleError(message) {
+    if (message.requestId) {
+      const pending = this.pendingRequests.get(message.requestId);
+      if (pending) {
+        pending.reject(new Error(message.error));
+        this.pendingRequests.delete(message.requestId);
+      }
+    } else {
+      console.error("[WorkerPool] Worker error:", message.error);
+    }
+  }
+  handleReady(message) {
+    if (message.type === "ready") {
+      console.info(`[WorkerPool] ServiceWorker ready (v${message.version})`);
+    } else if (message.type === "worker-ready") {
+      console.info("[WorkerPool] Worker initialized");
+    }
+  }
+  /**
+   * Platform-specific cache message handling
+   * Override this method in platform implementations for custom cache coordination
+   */
+  handleCacheMessage(message) {
+  }
+  /**
+   * Handle HTTP request using round-robin worker selection
+   */
+  async handleRequest(request) {
+    const worker = this.workers[this.currentWorker];
+    console.info(
+      `[WorkerPool] Dispatching to worker ${this.currentWorker + 1} of ${this.workers.length}`
+    );
+    this.currentWorker = (this.currentWorker + 1) % this.workers.length;
+    const requestId = ++this.requestId;
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(requestId, { resolve, reject });
+      const workerRequest = {
+        type: "request",
+        request: {
+          url: request.url,
+          method: request.method,
+          headers: Object.fromEntries(request.headers.entries()),
+          body: request.body
+        },
+        requestId
+      };
+      worker.postMessage(workerRequest);
+      setTimeout(() => {
+        if (this.pendingRequests.has(requestId)) {
+          this.pendingRequests.delete(requestId);
+          reject(new Error("Request timeout"));
+        }
+      }, this.options.requestTimeout);
+    });
+  }
+  /**
+   * Reload ServiceWorker with new version (hot reload simulation)
+   */
+  async reloadWorkers(version = Date.now()) {
+    console.info(`[WorkerPool] Reloading ServiceWorker (v${version})`);
+    const loadPromises = this.workers.map((worker) => {
+      return new Promise((resolve) => {
+        const handleReady = (event) => {
+          const message = event.data || event;
+          if (message.type === "ready" && message.version === version) {
+            worker.removeEventListener("message", handleReady);
+            resolve();
+          }
+        };
+        console.info("[WorkerPool] Sending load message:", {
+          version,
+          entrypoint: this.appEntrypoint
+        });
+        worker.addEventListener("message", handleReady);
+        const loadMessage = {
+          type: "load",
+          version,
+          entrypoint: this.appEntrypoint
+        };
+        worker.postMessage(loadMessage);
+      });
+    });
+    await Promise.all(loadPromises);
+    console.info(`[WorkerPool] All workers reloaded (v${version})`);
+  }
+  /**
+   * Graceful shutdown of all workers
+   */
+  async terminate() {
+    const terminatePromises = this.workers.map((worker) => worker.terminate());
+    await Promise.allSettled(terminatePromises);
+    this.workers = [];
+    this.pendingRequests.clear();
+  }
+  /**
+   * Get the number of active workers
+   */
+  get workerCount() {
+    return this.workers.length;
+  }
+  /**
+   * Check if the pool is ready to handle requests
+   */
+  get ready() {
+    return this.workers.length > 0;
+  }
+};
+export {
+  WorkerPool
+};

package/src/worker-web.js

@@ -0,0 +1,119 @@
+// src/worker-web.js
+async function initializeWorker() {
+  let messagePort = self;
+  let sendMessage2 = (message) => postMessage(message);
+  onmessage = function(event) {
+    handleMessage(event.data);
+  };
+  return { messagePort, sendMessage: sendMessage2 };
+}
+var { createServiceWorkerGlobals, ServiceWorkerRuntime, createBucketStorage } = await import("./index.js");
+var { CustomCacheStorage, PostMessageCache } = await import("@b9g/cache");
+var caches = new CustomCacheStorage((name) => {
+  return new PostMessageCache(name, {
+    maxEntries: 1e3,
+    maxAge: 60 * 60 * 1e3
+    // 1 hour
+  });
+});
+var buckets = createBucketStorage(process.cwd() + "/dist");
+var runtime = new ServiceWorkerRuntime();
+createServiceWorkerGlobals(runtime, { caches, buckets });
+var workerSelf = runtime;
+var currentApp = null;
+var serviceWorkerReady = false;
+var loadedVersion = null;
+async function handleFetchEvent(request) {
+  if (!currentApp || !serviceWorkerReady) {
+    throw new Error("ServiceWorker not ready");
+  }
+  try {
+    const response = await runtime.handleRequest(request);
+    return response;
+  } catch (error) {
+    console.error("[Worker] ServiceWorker request failed:", error);
+    const response = new Response("ServiceWorker request failed", {
+      status: 500
+    });
+    return response;
+  }
+}
+async function loadServiceWorker(version, entrypoint) {
+  try {
+    console.info("[Worker] loadServiceWorker called with:", { version, entrypoint });
+    const entrypointPath = process.env.SERVICEWORKER_PATH || entrypoint || `${process.cwd()}/dist/server/app.js`;
+    console.info("[Worker] Loading from:", entrypointPath);
+    if (loadedVersion !== null && loadedVersion !== version) {
+      console.info(`[Worker] Hot reload detected: ${loadedVersion} -> ${version}`);
+      console.info("[Worker] Creating completely fresh ServiceWorker context");
+      runtime = new ServiceWorkerRuntime();
+      createServiceWorkerGlobals(runtime, { caches, buckets });
+      workerSelf = runtime;
+      currentApp = null;
+      serviceWorkerReady = false;
+    }
+    if (loadedVersion === version) {
+      console.info("[Worker] ServiceWorker already loaded for version", version);
+      return;
+    }
+    globalThis.self = runtime;
+    globalThis.addEventListener = runtime.addEventListener.bind(runtime);
+    globalThis.removeEventListener = runtime.removeEventListener.bind(runtime);
+    globalThis.dispatchEvent = runtime.dispatchEvent.bind(runtime);
+    const appModule = await import(`${entrypointPath}?v=${version}`);
+    loadedVersion = version;
+    currentApp = appModule;
+    await runtime.install();
+    await runtime.activate();
+    serviceWorkerReady = true;
+    console.info(`[Worker] ServiceWorker loaded and activated (v${version}) from ${entrypointPath}`);
+  } catch (error) {
+    console.error("[Worker] Failed to load ServiceWorker:", error);
+    serviceWorkerReady = false;
+    throw error;
+  }
+}
+var workerId = Math.random().toString(36).substring(2, 8);
+var sendMessage;
+async function handleMessage(message) {
+  try {
+    if (message.type === "load") {
+      await loadServiceWorker(message.version, message.entrypoint);
+      sendMessage({ type: "ready", version: message.version });
+    } else if (message.type === "request") {
+      console.log(`[Worker-${workerId}] Handling request:`, message.request.url);
+      const request = new Request(message.request.url, {
+        method: message.request.method,
+        headers: message.request.headers,
+        body: message.request.body
+      });
+      const response = await handleFetchEvent(request);
+      sendMessage({
+        type: "response",
+        response: {
+          status: response.status,
+          statusText: response.statusText,
+          headers: Object.fromEntries(response.headers.entries()),
+          body: await response.text()
+        },
+        requestId: message.requestId
+      });
+    } else if (message.type.startsWith("cache:") || message.type.startsWith("cachestorage:")) {
+    } else {
+      console.warn("[Worker] Unknown message type:", message.type);
+    }
+  } catch (error) {
+    sendMessage({
+      type: "error",
+      error: error.message,
+      stack: error.stack,
+      requestId: message.requestId
+    });
+  }
+}
+initializeWorker().then(({ messagePort, sendMessage: send }) => {
+  sendMessage = send;
+  sendMessage({ type: "worker-ready" });
+}).catch((error) => {
+  console.error("[Worker] Failed to initialize:", error);
+});