@b9g/platform 0.1.4 → 0.1.6

package/src/single-threaded.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @b9g/platform/single-threaded - Single-threaded ServiceWorker runtime
+ *
+ * Runs ServiceWorker code directly in the main thread without spawning workers.
+ * Used when workerCount === 1 for maximum performance (no postMessage overhead).
+ */
+import { CustomBucketStorage } from "@b9g/filesystem";
+import { type ProcessedShovelConfig } from "./config.js";
+export interface SingleThreadedRuntimeOptions {
+    /** Base directory for bucket path resolution (entrypoint directory) - REQUIRED */
+    baseDir: string;
+    /** Optional pre-created cache storage (for sharing across reloads) */
+    cacheStorage?: CacheStorage;
+    /** Optional pre-created bucket storage */
+    bucketStorage?: CustomBucketStorage;
+    /** Shovel configuration for bucket/cache settings */
+    config?: ProcessedShovelConfig;
+}
+/**
+ * Single-threaded ServiceWorker runtime
+ *
+ * Provides the same interface as ServiceWorkerPool but runs everything
+ * in the main thread for zero postMessage overhead.
+ */
+export declare class SingleThreadedRuntime {
+    #private;
+    constructor(options: SingleThreadedRuntimeOptions);
+    /**
+     * Initialize the runtime (install scope as globalThis.self)
+     */
+    init(): Promise<void>;
+    /**
+     * Load and run a ServiceWorker entrypoint
+     */
+    reloadWorkers(version?: number | string): Promise<void>;
+    /**
+     * Load a ServiceWorker entrypoint for the first time
+     */
+    loadEntrypoint(entrypoint: string, version?: number | string): Promise<void>;
+    /**
+     * Handle an HTTP request
+     * This is the key method - direct call, no postMessage!
+     */
+    handleRequest(request: Request): Promise<Response>;
+    /**
+     * Graceful shutdown
+     */
+    terminate(): Promise<void>;
+    /**
+     * Get the number of workers (always 1 for single-threaded)
+     */
+    get workerCount(): number;
+    /**
+     * Check if ready to handle requests
+     */
+    get ready(): boolean;
+}

package/src/single-threaded.js

@@ -0,0 +1,107 @@
+/// <reference types="./single-threaded.d.ts" />
+// src/single-threaded.ts
+import { getLogger } from "@logtape/logtape";
+import { ShovelGlobalScope, ShovelServiceWorkerRegistration } from "./runtime.js";
+import { CustomBucketStorage } from "@b9g/filesystem";
+import { CustomCacheStorage } from "@b9g/cache";
+import {
+  createBucketFactory,
+  createCacheFactory
+} from "./config.js";
+var logger = getLogger(["single-threaded"]);
+var SingleThreadedRuntime = class {
+  #registration;
+  #scope;
+  #ready;
+  #entrypoint;
+  #config;
+  constructor(options) {
+    this.#ready = false;
+    this.#config = options.config;
+    const cacheStorage = options.cacheStorage || new CustomCacheStorage(createCacheFactory({ config: options.config }));
+    const bucketStorage = options.bucketStorage || new CustomBucketStorage(
+      createBucketFactory({ baseDir: options.baseDir, config: options.config })
+    );
+    this.#registration = new ShovelServiceWorkerRegistration();
+    this.#scope = new ShovelGlobalScope({
+      registration: this.#registration,
+      caches: cacheStorage,
+      buckets: bucketStorage
+    });
+    logger.info("SingleThreadedRuntime created", { baseDir: options.baseDir });
+  }
+  /**
+   * Initialize the runtime (install scope as globalThis.self)
+   */
+  async init() {
+    this.#scope.install();
+    logger.info("SingleThreadedRuntime initialized - scope installed");
+  }
+  /**
+   * Load and run a ServiceWorker entrypoint
+   */
+  async reloadWorkers(version) {
+    if (!this.#entrypoint) {
+      throw new Error("No entrypoint set - call loadEntrypoint first");
+    }
+    logger.info("Reloading ServiceWorker", {
+      version,
+      entrypoint: this.#entrypoint
+    });
+    const importPath = version ? `${this.#entrypoint}?v=${version}` : this.#entrypoint;
+    this.#registration._serviceWorker._setState("parsed");
+    this.#ready = false;
+    await import(importPath);
+    await this.#registration.install();
+    await this.#registration.activate();
+    this.#ready = true;
+    logger.info("ServiceWorker loaded and activated", { version });
+  }
+  /**
+   * Load a ServiceWorker entrypoint for the first time
+   */
+  async loadEntrypoint(entrypoint, version) {
+    this.#entrypoint = entrypoint;
+    logger.info("Loading ServiceWorker entrypoint", { entrypoint, version });
+    const importPath = version ? `${entrypoint}?v=${version}` : entrypoint;
+    await import(importPath);
+    await this.#registration.install();
+    await this.#registration.activate();
+    this.#ready = true;
+    logger.info("ServiceWorker loaded and activated", { entrypoint });
+  }
+  /**
+   * Handle an HTTP request
+   * This is the key method - direct call, no postMessage!
+   */
+  async handleRequest(request) {
+    if (!this.#ready) {
+      throw new Error(
+        "SingleThreadedRuntime not ready - ServiceWorker not loaded"
+      );
+    }
+    return this.#registration.handleRequest(request);
+  }
+  /**
+   * Graceful shutdown
+   */
+  async terminate() {
+    this.#ready = false;
+    logger.info("SingleThreadedRuntime terminated");
+  }
+  /**
+   * Get the number of workers (always 1 for single-threaded)
+   */
+  get workerCount() {
+    return 1;
+  }
+  /**
+   * Check if ready to handle requests
+   */
+  get ready() {
+    return this.#ready;
+  }
+};
+export {
+  SingleThreadedRuntime
+};

package/src/worker-pool.d.ts

@@ -1,15 +1,14 @@
 /**
- * Common WorkerPool abstraction based on web standards
- * Provides platform-agnostic worker management for ServiceWorker execution
+ * @b9g/platform/worker-pool - ServiceWorker pool implementation
+ *
+ * Manages a pool of workers that run the ServiceWorker runtime.
+ * Handles worker lifecycle, message passing, and request routing.
  */
-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;
 }
@@ -23,9 +22,9 @@ export interface WorkerRequest extends WorkerMessage {
         url: string;
         method: string;
         headers: Record<string, string>;
-        body?: any;
+        body?: ArrayBuffer | null;
     };
-    requestId: number;
+    requestID: number;
 }
 export interface WorkerResponse extends WorkerMessage {
     type: "response";
@@ -33,9 +32,9 @@ export interface WorkerResponse extends WorkerMessage {
         status: number;
         statusText: string;
         headers: Record<string, string>;
-        body: string;
+        body: ArrayBuffer;
     };
-    requestId: number;
+    requestID: number;
 }
 export interface WorkerLoadMessage extends WorkerMessage {
     type: "load";
@@ -50,36 +49,27 @@ export interface WorkerErrorMessage extends WorkerMessage {
     type: "error";
     error: string;
     stack?: string;
-    requestId?: number;
+    requestID?: number;
+}
+export interface WorkerInitMessage extends WorkerMessage {
+    type: "init";
+    config: any;
+    baseDir: string;
+}
+export interface WorkerInitializedMessage extends WorkerMessage {
+    type: "initialized";
 }
 /**
- * Common WorkerPool implementation based on web standards
- * Provides round-robin request handling, hot reloading, and cache coordination
+ * ServiceWorkerPool - manages a pool of ServiceWorker instances
+ * Handles HTTP request/response routing, cache coordination, and hot reloading
  */
-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);
+export declare class ServiceWorkerPool {
+    #private;
+    constructor(options?: WorkerPoolOptions, appEntrypoint?: string, cacheStorage?: CacheStorage, config?: any);
     /**
      * 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
      */