@b9g/platform 0.1.3 → 0.1.5

package/src/worker-pool.js

@@ -9,6 +9,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/worker-pool.ts
 import * as Path from "path";
+import { existsSync } from "fs";
+import { getLogger } from "@logtape/logtape";
+var logger = getLogger(["worker"]);
 function resolveWorkerScript(entrypoint) {
   if (entrypoint) {
     const entryDir = Path.dirname(entrypoint);
@@ -17,13 +20,12 @@ function resolveWorkerScript(entrypoint) {
       if (typeof Bun !== "undefined") {
         const file = Bun.file(bundledWorker);
         if (file.size > 0) {
-          console.debug(`[WorkerPool] Using bundled worker: ${bundledWorker}`);
+          logger.info("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}`);
+        if (existsSync(bundledWorker)) {
+          logger.info("Using bundled worker", { bundledWorker });
           return bundledWorker;
         }
       }
@@ -31,19 +33,19 @@ function resolveWorkerScript(entrypoint) {
     }
   }
   try {
-    const workerUrl = import.meta.resolve("@b9g/platform/worker-web.js");
+    const workerURL = import.meta.resolve("@b9g/platform/runtime.js");
     let workerScript;
-    if (workerUrl.startsWith("file://")) {
-      workerScript = workerUrl.slice(7);
+    if (workerURL.startsWith("file://")) {
+      workerScript = workerURL.slice(7);
     } else {
-      workerScript = workerUrl;
+      workerScript = workerURL;
     }
-    console.debug(`[WorkerPool] Using Web Worker-compatible script: ${workerScript}`);
+    logger.info("Using worker runtime script", { workerScript });
     return workerScript;
   } catch (error) {
-    const bundledPath = entrypoint ? Path.join(Path.dirname(entrypoint), "worker-web.js") : "worker-web.js";
+    const bundledPath = entrypoint ? Path.join(Path.dirname(entrypoint), "runtime.js") : "runtime.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)}`
+      `Could not resolve runtime.js. Checked bundled path: ${bundledPath} and package: @b9g/platform/runtime.js. Error: ${error instanceof Error ? error.message : String(error)}`
     );
   }
 }
@@ -55,13 +57,18 @@ async function createWebWorker(workerScript) {
   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" });
+      logger.info("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");
+      logger.error(
+        "MISSING WEB STANDARD: Node.js lacks native Web Worker support",
+        {
+          canonicalIssue: "https://github.com/nodejs/node/issues/43583",
+          message: "This is a basic web standard from 2009 - help push for implementation!"
+        }
+      );
       throw new Error(`\u274C Web Worker not available on Node.js
 
 \u{1F517} Node.js doesn't implement the Web Worker standard yet.
@@ -85,22 +92,30 @@ 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 = {
+var ServiceWorkerPool = class {
+  #workers;
+  #currentWorker;
+  #requestID;
+  #pendingRequests;
+  #pendingWorkerInit;
+  #options;
+  #appEntrypoint;
+  #cacheStorage;
+  // CustomCacheStorage for cache coordination
+  #config;
+  // ShovelConfig from config.ts
+  constructor(options = {}, appEntrypoint, cacheStorage, config) {
+    this.#workers = [];
+    this.#currentWorker = 0;
+    this.#requestID = 0;
+    this.#pendingRequests = /* @__PURE__ */ new Map();
+    this.#pendingWorkerInit = /* @__PURE__ */ new Map();
+    this.#appEntrypoint = appEntrypoint;
+    this.#cacheStorage = cacheStorage;
+    this.#config = config || {};
+    this.#options = {
       workerCount: 1,
       requestTimeout: 3e4,
-      hotReload: process.env.NODE_ENV !== "production",
-      cwd: process.cwd(),
       ...options
     };
   }
@@ -108,47 +123,106 @@ var WorkerPool = class {
    * Initialize workers (must be called after construction)
    */
   async init() {
-    await this.initWorkers();
+    await this.#initWorkers();
   }
-  async initWorkers() {
-    for (let i = 0; i < this.options.workerCount; i++) {
-      await this.createWorker();
+  async #initWorkers() {
+    for (let i = 0; i < this.#options.workerCount; i++) {
+      await this.#createWorker();
     }
   }
-  async createWorker() {
-    const workerScript = resolveWorkerScript(this.appEntrypoint);
+  async #createWorker() {
+    const workerScript = resolveWorkerScript(this.#appEntrypoint);
     const worker = await createWebWorker(workerScript);
+    const workerReadyPromise = new Promise((resolve) => {
+      this.#pendingWorkerInit.set(worker, {
+        workerReady: resolve
+      });
+    });
     worker.addEventListener("message", (event) => {
-      this.handleWorkerMessage(event.data || event);
+      this.#handleWorkerMessage(worker, event.data || event);
     });
-    worker.addEventListener("error", (error) => {
-      console.error("[WorkerPool] Worker error:", error);
+    worker.addEventListener("error", (event) => {
+      logger.error("Worker error", {
+        message: event.message || event.error?.message,
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+        error: event.error,
+        stack: event.error?.stack
+      });
+    });
+    this.#workers.push(worker);
+    logger.info("Waiting for worker-ready signal");
+    await workerReadyPromise;
+    logger.info("Received worker-ready signal");
+    const initializedPromise = new Promise((resolve) => {
+      const pending = this.#pendingWorkerInit.get(worker) || {};
+      pending.initialized = resolve;
+      this.#pendingWorkerInit.set(worker, pending);
     });
-    this.workers.push(worker);
+    if (!this.#appEntrypoint) {
+      throw new Error(
+        "ServiceWorkerPool requires an entrypoint to derive baseDir"
+      );
+    }
+    const baseDir = Path.dirname(this.#appEntrypoint);
+    const initMessage = {
+      type: "init",
+      config: this.#config,
+      baseDir
+    };
+    logger.info("Sending init message", { config: this.#config, baseDir });
+    worker.postMessage(initMessage);
+    logger.info("Sent init message, waiting for initialized response");
+    await initializedPromise;
+    logger.info("Received initialized response");
+    this.#pendingWorkerInit.delete(worker);
     return worker;
   }
-  handleWorkerMessage(message) {
-    if (message.type?.startsWith("cache:")) {
-      this.handleCacheMessage(message);
+  #handleWorkerMessage(worker, message) {
+    logger.debug("Worker message received", { type: message.type });
+    const pending = this.#pendingWorkerInit.get(worker);
+    if (message.type === "worker-ready" && pending?.workerReady) {
+      pending.workerReady();
+    } else if (message.type === "initialized" && pending?.initialized) {
+      pending.initialized();
       return;
     }
     switch (message.type) {
       case "response":
-        this.handleResponse(message);
+        this.#handleResponse(message);
         break;
       case "error":
-        this.handleError(message);
+        this.#handleError(message);
         break;
       case "ready":
       case "worker-ready":
-        this.handleReady(message);
+        this.#handleReady(message);
+        break;
+      case "initialized":
         break;
       default:
-        console.warn("[WorkerPool] Unknown message type:", message.type);
+        if (message.type?.startsWith("cache:")) {
+          logger.debug("Cache message detected", {
+            type: message.type,
+            hasStorage: !!this.#cacheStorage
+          });
+          if (this.#cacheStorage) {
+            const handleMessage = this.#cacheStorage.handleMessage;
+            logger.debug("handleMessage check", {
+              hasMethod: typeof handleMessage === "function"
+            });
+            if (typeof handleMessage === "function") {
+              logger.debug("Calling handleMessage");
+              void handleMessage.call(this.#cacheStorage, worker, message);
+            }
+          }
+        }
+        break;
     }
   }
-  handleResponse(message) {
-    const pending = this.pendingRequests.get(message.requestId);
+  #handleResponse(message) {
+    const pending = this.#pendingRequests.get(message.requestID);
     if (pending) {
       const response = new Response(message.response.body, {
         status: message.response.status,
@@ -156,116 +230,156 @@ var WorkerPool = class {
         headers: message.response.headers
       });
       pending.resolve(response);
-      this.pendingRequests.delete(message.requestId);
+      this.#pendingRequests.delete(message.requestID);
     }
   }
-  handleError(message) {
-    if (message.requestId) {
-      const pending = this.pendingRequests.get(message.requestId);
+  #handleError(message) {
+    logger.error("Worker error message received", {
+      error: message.error,
+      stack: message.stack,
+      requestID: message.requestID
+    });
+    if (message.requestID) {
+      const pending = this.#pendingRequests.get(message.requestID);
       if (pending) {
         pending.reject(new Error(message.error));
-        this.pendingRequests.delete(message.requestId);
+        this.#pendingRequests.delete(message.requestID);
       }
     } else {
-      console.error("[WorkerPool] Worker error:", message.error);
+      logger.error("Worker error", { error: message.error });
     }
   }
-  handleReady(message) {
+  #handleReady(message) {
     if (message.type === "ready") {
-      console.info(`[WorkerPool] ServiceWorker ready (v${message.version})`);
+      logger.info("ServiceWorker ready", { version: message.version });
     } else if (message.type === "worker-ready") {
-      console.info("[WorkerPool] Worker initialized");
+      logger.info("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;
+    const worker = this.#workers[this.#currentWorker];
+    logger.info("Dispatching to worker", {
+      workerIndex: this.#currentWorker + 1,
+      totalWorkers: 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);
+      this.#pendingRequests.set(requestID, { resolve, reject });
+      this.#sendRequest(worker, request, requestID).catch(reject);
       setTimeout(() => {
-        if (this.pendingRequests.has(requestId)) {
-          this.pendingRequests.delete(requestId);
+        if (this.#pendingRequests.has(requestID)) {
+          this.#pendingRequests.delete(requestID);
           reject(new Error("Request timeout"));
         }
-      }, this.options.requestTimeout);
+      }, this.#options.requestTimeout);
     });
   }
+  /**
+   * Send request to worker (async helper to avoid async promise executor)
+   */
+  async #sendRequest(worker, request, requestID) {
+    let body = null;
+    if (request.body) {
+      body = await request.arrayBuffer();
+    }
+    const workerRequest = {
+      type: "request",
+      request: {
+        url: request.url,
+        method: request.method,
+        headers: Object.fromEntries(request.headers.entries()),
+        body
+      },
+      requestID
+    };
+    if (body) {
+      worker.postMessage(workerRequest, [body]);
+    } else {
+      worker.postMessage(workerRequest);
+    }
+  }
   /**
    * 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) => {
+    logger.info("Reloading ServiceWorker", { version });
+    const loadPromises = this.#workers.map((worker) => {
+      return new Promise((resolve, reject) => {
+        let timeoutId;
+        const cleanup = () => {
+          worker.removeEventListener("message", handleReady);
+          worker.removeEventListener("error", handleError);
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+        };
         const handleReady = (event) => {
           const message = event.data || event;
           if (message.type === "ready" && message.version === version) {
-            worker.removeEventListener("message", handleReady);
+            cleanup();
             resolve();
           }
         };
-        console.info("[WorkerPool] Sending load message:", {
+        const handleError = (error) => {
+          cleanup();
+          const errorMsg = error?.error?.message || error?.message || JSON.stringify(error);
+          reject(new Error(`Worker failed to load ServiceWorker: ${errorMsg}`));
+        };
+        timeoutId = setTimeout(() => {
+          cleanup();
+          reject(
+            new Error(
+              `Worker failed to load ServiceWorker within 30000ms (version ${version})`
+            )
+          );
+        }, 3e4);
+        logger.info("Sending load message", {
           version,
-          entrypoint: this.appEntrypoint
+          entrypoint: this.#appEntrypoint
         });
         worker.addEventListener("message", handleReady);
+        worker.addEventListener("error", handleError);
         const loadMessage = {
           type: "load",
           version,
-          entrypoint: this.appEntrypoint
+          entrypoint: this.#appEntrypoint
         };
+        logger.debug("[WorkerPool] Sending load message", {
+          entrypoint: this.#appEntrypoint,
+          version
+        });
         worker.postMessage(loadMessage);
       });
     });
     await Promise.all(loadPromises);
-    console.info(`[WorkerPool] All workers reloaded (v${version})`);
+    logger.info("All workers reloaded", { version });
   }
   /**
    * Graceful shutdown of all workers
    */
   async terminate() {
-    const terminatePromises = this.workers.map((worker) => worker.terminate());
+    const terminatePromises = this.#workers.map((worker) => worker.terminate());
     await Promise.allSettled(terminatePromises);
-    this.workers = [];
-    this.pendingRequests.clear();
+    this.#workers = [];
+    this.#pendingRequests.clear();
   }
   /**
    * Get the number of active workers
    */
   get workerCount() {
-    return this.workers.length;
+    return this.#workers.length;
   }
   /**
    * Check if the pool is ready to handle requests
    */
   get ready() {
-    return this.workers.length > 0;
+    return this.#workers.length > 0;
   }
 };
 export {
-  WorkerPool
+  ServiceWorkerPool
 };

package/src/adapter-registry.d.ts

@@ -1,53 +0,0 @@
-/**
- * Blessed alias registry for official Shovel adapters
- * Maps short names to full package names for CLI convenience
- */
-export interface AdapterModule {
-    createCache?: (config: any) => any;
-    createFileSystem?: (config: any) => any;
-}
-/**
- * Official blessed aliases for cache adapters
- */
-export declare const CACHE_ALIASES: {
-    readonly memory: "@b9g/cache";
-    readonly redis: "@b9g/cache-redis";
-    readonly kv: "@b9g/cache-kv";
-    readonly cloudflare: "@b9g/cache/cloudflare";
-};
-/**
- * Official blessed aliases for filesystem adapters
- */
-export declare const FILESYSTEM_ALIASES: {
-    readonly memory: "@b9g/filesystem";
-    readonly fs: "@b9g/filesystem/node";
-    readonly "bun-s3": "@b9g/filesystem/bun-s3";
-    readonly s3: "@b9g/filesystem-s3";
-    readonly r2: "@b9g/filesystem-r2";
-};
-/**
- * Resolve a cache adapter name to a package name
- * @param name - Blessed alias (memory, redis) or full package name (@custom/cache)
- * @returns Full package name
- */
-export declare function resolveCacheAdapter(name: string): string;
-/**
- * Resolve a filesystem adapter name to a package name
- * @param name - Blessed alias (memory, s3) or full package name (@custom/filesystem)
- * @returns Full package name
- */
-export declare function resolveFilesystemAdapter(name: string): string;
-/**
- * Dynamically load a cache adapter
- * @param name - Adapter name (blessed alias or package name)
- * @param config - Adapter configuration
- * @returns Cache instance
- */
-export declare function loadCacheAdapter(name: string, config?: any): Promise<any>;
-/**
- * Dynamically load a filesystem adapter
- * @param name - Adapter name (blessed alias or package name)
- * @param config - Adapter configuration
- * @returns Filesystem adapter instance
- */
-export declare function loadFilesystemAdapter(name: string, config?: any): Promise<any>;

package/src/adapter-registry.js

@@ -1,71 +0,0 @@
-/// <reference types="./adapter-registry.d.ts" />
-// src/adapter-registry.ts
-var CACHE_ALIASES = {
-  memory: "@b9g/cache",
-  redis: "@b9g/cache-redis",
-  kv: "@b9g/cache-kv",
-  cloudflare: "@b9g/cache/cloudflare"
-};
-var FILESYSTEM_ALIASES = {
-  memory: "@b9g/filesystem",
-  fs: "@b9g/filesystem/node",
-  "bun-s3": "@b9g/filesystem/bun-s3",
-  s3: "@b9g/filesystem-s3",
-  r2: "@b9g/filesystem-r2"
-};
-function resolveCacheAdapter(name) {
-  if (name.startsWith("@")) {
-    return name;
-  }
-  if (name in CACHE_ALIASES) {
-    return CACHE_ALIASES[name];
-  }
-  throw new Error(`Unknown cache adapter: ${name}. Available aliases: ${Object.keys(CACHE_ALIASES).join(", ")} or use full package name like @custom/cache`);
-}
-function resolveFilesystemAdapter(name) {
-  if (name.startsWith("@")) {
-    return name;
-  }
-  if (name in FILESYSTEM_ALIASES) {
-    return FILESYSTEM_ALIASES[name];
-  }
-  throw new Error(`Unknown filesystem adapter: ${name}. Available aliases: ${Object.keys(FILESYSTEM_ALIASES).join(", ")} or use full package name like @custom/filesystem`);
-}
-async function loadCacheAdapter(name, config = {}) {
-  const packageName = resolveCacheAdapter(name);
-  try {
-    const module = await import(packageName);
-    if (!module.createCache) {
-      throw new Error(`Package ${packageName} does not export a createCache function`);
-    }
-    return module.createCache(config);
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Cannot resolve module")) {
-      throw new Error(`Cache adapter '${name}' requires: npm install ${packageName}`);
-    }
-    throw error;
-  }
-}
-async function loadFilesystemAdapter(name, config = {}) {
-  const packageName = resolveFilesystemAdapter(name);
-  try {
-    const module = await import(packageName);
-    if (!module.createFileSystem) {
-      throw new Error(`Package ${packageName} does not export a createFileSystem function`);
-    }
-    return module.createFileSystem(config);
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Cannot resolve module")) {
-      throw new Error(`Filesystem adapter '${name}' requires: npm install ${packageName}`);
-    }
-    throw error;
-  }
-}
-export {
-  CACHE_ALIASES,
-  FILESYSTEM_ALIASES,
-  loadCacheAdapter,
-  loadFilesystemAdapter,
-  resolveCacheAdapter,
-  resolveFilesystemAdapter
-};

package/src/base-platform.d.ts

@@ -1,49 +0,0 @@
-/**
- * Base platform implementation with dynamic adapter loading
- * Provides common functionality for all platform implementations
- */
-import type { Platform, PlatformConfig, CacheConfig, CacheBackendConfig, FilesystemConfig } from "./types.js";
-import type { CacheStorage } from "@b9g/cache/cache-storage";
-/**
- * Base platform class with shared adapter loading logic
- * Platform implementations extend this and provide platform-specific methods
- */
-export declare abstract class BasePlatform implements Platform {
-    protected config: PlatformConfig;
-    constructor(config?: PlatformConfig);
-    abstract readonly name: string;
-    abstract loadServiceWorker(entrypoint: string, options?: any): Promise<any>;
-    abstract createServer(handler: any, options?: any): any;
-    abstract getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-    /**
-     * Create cache storage with dynamic adapter loading
-     * Uses platform defaults when specific cache types aren't configured
-     */
-    createCaches(config?: CacheConfig): Promise<CacheStorage>;
-    /**
-     * Get platform-specific default cache configuration
-     * Subclasses override this to provide optimal defaults for their runtime
-     */
-    protected getDefaultCacheConfig(): CacheConfig;
-    /**
-     * Merge user config with platform defaults
-     */
-    protected mergeCacheConfig(userConfig?: CacheConfig): CacheConfig;
-    /**
-     * Build CacheStorage instance with dynamic adapter loading
-     */
-    protected buildCacheStorage(config: CacheConfig): Promise<CacheStorage>;
-    /**
-     * Load a single cache instance using dynamic import
-     */
-    protected loadCacheInstance(config: CacheBackendConfig): Promise<any>;
-    /**
-     * Load filesystem adapter using dynamic import
-     */
-    protected loadFilesystemAdapter(config?: FilesystemConfig): Promise<any>;
-    /**
-     * Get platform-specific default filesystem configuration
-     * Subclasses override this to provide optimal defaults for their runtime
-     */
-    protected getDefaultFilesystemConfig(): FilesystemConfig;
-}