@b9g/platform 0.1.1 → 0.1.3

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