@b9g/platform 0.1.1 → 0.1.3

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
      */
@@ -75,25 +91,29 @@ export declare class ServiceWorkerRuntime extends EventTarget {
     reset(): void;
 }
 /**
- * Directory storage interface - parallels CacheStorage for filesystem access
+ * Bucket storage interface - parallels CacheStorage for filesystem access
  * This could become a future web standard
  */
-export interface DirectoryStorage {
+export interface BucketStorage {
     /**
-     * Open a named directory - returns FileSystemDirectoryHandle
-     * Well-known names: 'assets', 'static', 'server', 'client'
+     * Open a named bucket - returns FileSystemDirectoryHandle (root of that bucket)
+     * Well-known names: 'assets', 'static', 'uploads', 'temp'
      */
     open(name: string): Promise<FileSystemDirectoryHandle>;
     /**
-     * Check if a named directory exists
+     * Alias for open() - for compatibility with File System Access API naming
+     */
+    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
+    /**
+     * Check if a named bucket exists
      */
     has(name: string): Promise<boolean>;
     /**
-     * Delete a named directory and all its contents
+     * Delete a named bucket and all its contents
      */
     delete(name: string): Promise<boolean>;
     /**
-     * List all available directory names
+     * List all available bucket names
      */
     keys(): Promise<string[]>;
 }
@@ -102,17 +122,10 @@ export interface DirectoryStorage {
  */
 export declare function createServiceWorkerGlobals(runtime: ServiceWorkerRuntime, options?: {
     caches?: any;
-    dirs?: DirectoryStorage;
+    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,32 +172,53 @@ 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 = {}) {
   if (options.caches) {
     runtime.caches = options.caches;
   }
-  if (options.dirs) {
-    runtime.dirs = options.dirs;
+  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/types.d.ts

@@ -87,6 +87,8 @@ export interface FilesystemConfig {
         secretAccessKey?: string;
         token?: string;
     };
+    /** Factory function for creating directory storage */
+    factory?: any;
     /** Additional adapter-specific options */
     [key: string]: any;
 }
@@ -166,13 +168,18 @@ export interface ServiceWorkerInstance {
  */
 export interface Server {
     /** Start listening for requests */
-    listen(): Promise<void> | void;
+    listen(): Promise<void>;
     /** Stop the server */
-    close(): Promise<void> | void;
+    close(): Promise<void>;
+    /** Get server address information */
+    address(): {
+        port: number;
+        host: string;
+    };
     /** Get server URL */
-    url?: string;
-    /** Platform-specific server instance */
-    instance?: any;
+    readonly url: string;
+    /** Whether server is ready to accept requests */
+    readonly ready: boolean;
 }
 /**
  * Platform interface - ServiceWorker entrypoint loader for JavaScript runtimes
@@ -184,11 +191,6 @@ export interface Platform {
      * Platform name for identification
      */
     readonly name: string;
-    /**
-     * Build artifacts filesystem (install-time only)
-     * Available during install handlers to copy built files to runtime storage
-     */
-    readonly distDir: FileSystemDirectoryHandle;
     /**
      * THE MAIN JOB - Load and run a ServiceWorker-style entrypoint
      * This is where all the platform-specific complexity lives
@@ -202,16 +204,21 @@ export interface Platform {
      * - Bun: filesystem with optimized writes
      */
     createCaches(config?: CacheConfig): Promise<CacheStorage>;
+    /**
+     * SUPPORTING UTILITY - Create bucket storage with platform-optimized backends
+     * Uses factory pattern to route bucket names to different filesystem adapters
+     */
+    createBuckets(config?: FilesystemConfig): Promise<any>;
     /**
      * SUPPORTING UTILITY - Create server instance for this platform
      */
     createServer(handler: Handler, options?: ServerOptions): Server;
     /**
-     * SUPPORTING UTILITY - Get filesystem root for bucket/container name
+     * SUPPORTING UTILITY - Get filesystem directory handle
      * Maps directly to cloud storage buckets (S3, R2) or local directories
-     * @param bucketName - The bucket/container/directory name
+     * @param name - Directory name. Use "" for root directory
      */
-    getFileSystemRoot(bucketName: string): Promise<FileSystemDirectoryHandle>;
+    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
 }
 /**
  * Platform detection result

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;
+}