@b9g/platform 0.1.10 → 0.1.12

package/src/worker-pool.js

@@ -1,391 +0,0 @@
-/// <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";
-import { existsSync } from "fs";
-import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["worker"]);
-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) {
-          logger.info("Using bundled worker", { bundledWorker });
-          return bundledWorker;
-        }
-      } else if (typeof __require !== "undefined") {
-        if (existsSync(bundledWorker)) {
-          logger.info("Using bundled worker", { bundledWorker });
-          return bundledWorker;
-        }
-      }
-    } catch {
-    }
-  }
-  try {
-    const workerURL = import.meta.resolve("@b9g/platform/runtime.js");
-    let workerScript;
-    if (workerURL.startsWith("file://")) {
-      workerScript = workerURL.slice(7);
-    } else {
-      workerScript = workerURL;
-    }
-    logger.info("Using worker runtime script", { workerScript });
-    return workerScript;
-  } catch (error) {
-    const bundledPath = entrypoint ? Path.join(Path.dirname(entrypoint), "runtime.js") : "runtime.js";
-    throw new Error(
-      `Could not resolve runtime.js. Checked bundled path: ${bundledPath} and package: @b9g/platform/runtime.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");
-      logger.info("Using @b9g/node-webworker shim for Node.js", {});
-      return new NodeWebWorker(workerScript, {
-        type: "module"
-      });
-    } catch (shimError) {
-      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.
-   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 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,
-      ...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);
-    const workerReadyPromise = new Promise((resolve) => {
-      this.#pendingWorkerInit.set(worker, {
-        workerReady: resolve
-      });
-    });
-    worker.addEventListener("message", (event) => {
-      this.#handleWorkerMessage(worker, event.data || event);
-    });
-    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);
-    });
-    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(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);
-        break;
-      case "error":
-        this.#handleError(message);
-        break;
-      case "ready":
-      case "worker-ready":
-        this.#handleReady(message);
-        break;
-      case "initialized":
-        break;
-      default:
-        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);
-    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) {
-    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);
-      }
-    } else {
-      logger.error("Worker error", { error: message.error });
-    }
-  }
-  #handleReady(message) {
-    if (message.type === "ready") {
-      logger.info("ServiceWorker ready", { entrypoint: message.entrypoint });
-    } else if (message.type === "worker-ready") {
-      logger.info("Worker initialized", {});
-    }
-  }
-  /**
-   * Handle HTTP request using round-robin worker selection
-   */
-  async handleRequest(request) {
-    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 });
-      this.#sendRequest(worker, request, requestID).catch(reject);
-      setTimeout(() => {
-        if (this.#pendingRequests.has(requestID)) {
-          this.#pendingRequests.delete(requestID);
-          reject(new Error("Request timeout"));
-        }
-      }, 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 entrypoint (hot reload)
-   * The entrypoint path contains a content hash for cache busting
-   */
-  async reloadWorkers(entrypoint) {
-    logger.info("Reloading ServiceWorker", { entrypoint });
-    this.#appEntrypoint = entrypoint;
-    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.entrypoint === entrypoint) {
-            cleanup();
-            resolve();
-          } else if (message.type === "error") {
-            cleanup();
-            reject(
-              new Error(
-                `Worker failed to load ServiceWorker: ${message.error}`
-              )
-            );
-          }
-        };
-        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 (entrypoint ${entrypoint})`
-            )
-          );
-        }, 3e4);
-        logger.info("Sending load message", {
-          entrypoint
-        });
-        worker.addEventListener("message", handleReady);
-        worker.addEventListener("error", handleError);
-        const loadMessage = {
-          type: "load",
-          entrypoint
-        };
-        logger.debug("[WorkerPool] Sending load message", {
-          entrypoint
-        });
-        worker.postMessage(loadMessage);
-      });
-    });
-    await Promise.all(loadPromises);
-    logger.info("All workers reloaded", { entrypoint });
-  }
-  /**
-   * 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 {
-  ServiceWorkerPool
-};