@b9g/platform 0.1.11 → 0.1.12

package/src/index.js

@@ -1,43 +1,21 @@
 /// <reference types="./index.d.ts" />
-import "../chunk-P57PW2II.js";
+import {
+  __require
+} from "../chunk-P57PW2II.js";
 
 // src/index.ts
 import * as Path from "path";
-import { readFileSync } from "fs";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
 import { CustomCacheStorage } from "@b9g/cache";
 import { MemoryCache } from "@b9g/cache/memory";
+import { getLogger } from "@logtape/logtape";
 import {
-  ServiceWorkerPool
-} from "./worker-pool.js";
-import {
-  SingleThreadedRuntime
-} from "./single-threaded.js";
-import {
-  ShovelServiceWorkerRegistration,
   ServiceWorkerGlobals,
-  FetchEvent,
-  InstallEvent,
-  ActivateEvent,
-  ExtendableEvent
+  ShovelServiceWorkerRegistration,
+  CustomLoggerStorage
 } from "./runtime.js";
-import {
-  RequestCookieStore,
-  parseCookieHeader,
-  serializeCookie,
-  parseSetCookieHeader
-} from "./cookie-store.js";
-import { CustomBucketStorage } from "@b9g/filesystem";
-import {
-  loadConfig,
-  configureLogging,
-  getCacheConfig,
-  getBucketConfig,
-  parseConfigExpr,
-  processConfigValue,
-  matchPattern,
-  createBucketFactory,
-  createCacheFactory
-} from "./config.js";
+var logger = getLogger(["platform"]);
 function detectRuntime() {
   if (typeof Bun !== "undefined" || process.versions?.bun) {
     return "bun";
@@ -47,53 +25,6 @@ function detectRuntime() {
   }
   return "node";
 }
-function detectPlatformFromPackageJSON(cwd) {
-  if (!cwd && typeof process === "undefined") {
-    return null;
-  }
-  try {
-    const pkgPath = Path.join(cwd || process.cwd(), "package.json");
-    const pkgContent = readFileSync(pkgPath, "utf8");
-    const pkg = JSON.parse(pkgContent);
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    return selectPlatformFromDeps(deps);
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw err;
-    }
-    return null;
-  }
-}
-function selectPlatformFromDeps(deps) {
-  const hasBun = deps["@b9g/platform-bun"];
-  const hasNode = deps["@b9g/platform-node"];
-  const hasCloudflare = deps["@b9g/platform-cloudflare"];
-  const installedCount = [hasBun, hasNode, hasCloudflare].filter(
-    Boolean
-  ).length;
-  if (installedCount === 0)
-    return null;
-  if (installedCount === 1) {
-    if (hasBun)
-      return "bun";
-    if (hasNode)
-      return "node";
-    if (hasCloudflare)
-      return "cloudflare";
-  }
-  const runtime = detectRuntime();
-  if (runtime === "bun" && hasBun)
-    return "bun";
-  if (runtime === "node" && hasNode)
-    return "node";
-  if (hasBun)
-    return "bun";
-  if (hasNode)
-    return "node";
-  if (hasCloudflare)
-    return "cloudflare";
-  return null;
-}
 function detectDeploymentPlatform() {
   if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
     return null;
@@ -105,10 +36,6 @@ function detectDeploymentPlatform() {
   return null;
 }
 function detectDevelopmentPlatform() {
-  const pkgPlatform = detectPlatformFromPackageJSON();
-  if (pkgPlatform) {
-    return pkgPlatform;
-  }
   const runtime = detectRuntime();
   switch (runtime) {
     case "bun":
@@ -234,36 +161,494 @@ async function getPlatformAsync(name) {
   }
   return platform;
 }
+var SingleThreadedRuntime = class {
+  #registration;
+  #scope;
+  #ready;
+  #entrypoint;
+  constructor(options) {
+    this.#ready = false;
+    this.#registration = new ShovelServiceWorkerRegistration();
+    this.#scope = new ServiceWorkerGlobals({
+      registration: this.#registration,
+      caches: options.caches,
+      directories: options.directories,
+      loggers: options.loggers
+    });
+    logger.info("SingleThreadedRuntime created");
+  }
+  /**
+   * Initialize the runtime (install ServiceWorker globals)
+   */
+  async init() {
+    this.#scope.install();
+    logger.info("SingleThreadedRuntime initialized - globals installed");
+  }
+  /**
+   * Load (or reload) a ServiceWorker entrypoint
+   * @param entrypoint - Path to the entrypoint file (content-hashed filename)
+   */
+  async load(entrypoint) {
+    const isReload = this.#entrypoint !== void 0;
+    if (isReload) {
+      logger.info("Reloading ServiceWorker", {
+        oldEntrypoint: this.#entrypoint,
+        newEntrypoint: entrypoint
+      });
+      this.#registration._serviceWorker._setState("parsed");
+    } else {
+      logger.info("Loading ServiceWorker entrypoint", { entrypoint });
+    }
+    this.#entrypoint = entrypoint;
+    this.#ready = false;
+    await import(entrypoint);
+    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;
+  }
+};
+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 (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+  try {
+    const workerURL = import.meta.resolve("@b9g/platform/worker.js");
+    let workerScript;
+    if (workerURL.startsWith("file://")) {
+      workerScript = fileURLToPath(workerURL);
+    } else {
+      workerScript = workerURL;
+    }
+    logger.info("Using worker entry script", { workerScript });
+    return workerScript;
+  } catch (error) {
+    const bundledPath = entrypoint ? Path.join(Path.dirname(entrypoint), "worker.js") : "worker.js";
+    throw new Error(
+      `Could not resolve worker.js. Checked bundled path: ${bundledPath} and package: @b9g/platform/worker.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);
+    let rejectWorkerReady;
+    let workerReadyTimeoutId;
+    const workerReadyPromise = new Promise((resolve, reject) => {
+      rejectWorkerReady = reject;
+      workerReadyTimeoutId = setTimeout(() => {
+        reject(new Error("Worker failed to send ready signal within 30000ms"));
+      }, 3e4);
+      this.#pendingWorkerInit.set(worker, {
+        workerReady: () => {
+          clearTimeout(workerReadyTimeoutId);
+          resolve();
+        }
+      });
+    });
+    worker.addEventListener("message", (event) => {
+      this.#handleWorkerMessage(worker, event.data || event);
+    });
+    worker.addEventListener("error", (event) => {
+      const errorMessage = event.message || event.error?.message || "Unknown worker error";
+      const error = new Error(`Worker failed to start: ${errorMessage}`);
+      logger.error("Worker error: {error}", {
+        error: event.error || errorMessage,
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno
+      });
+      clearTimeout(workerReadyTimeoutId);
+      rejectWorkerReady(error);
+    });
+    this.#workers.push(worker);
+    logger.info("Waiting for worker-ready signal");
+    await workerReadyPromise;
+    logger.info("Received worker-ready signal");
+    const initializedPromise = new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(
+          new Error("Worker failed to send initialized signal within 30000ms")
+        );
+      }, 3e4);
+      const pending = this.#pendingWorkerInit.get(worker) || {};
+      pending.initialized = () => {
+        clearTimeout(timeoutId);
+        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 received", { type: message.type });
+          if (this.#cacheStorage) {
+            const storage = this.#cacheStorage;
+            if (typeof storage.handleMessage === "function") {
+              storage.handleMessage(worker, message).catch((err) => {
+                logger.error("Cache message handling failed: {error}", {
+                  error: err
+                });
+              });
+            }
+          }
+        }
+        break;
+    }
+  }
+  #handleResponse(message) {
+    const pending = this.#pendingRequests.get(message.requestID);
+    if (pending) {
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      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}", {
+      error: message.error,
+      stack: message.stack,
+      requestID: message.requestID
+    });
+    if (message.requestID) {
+      const pending = this.#pendingRequests.get(message.requestID);
+      if (pending) {
+        if (pending.timeoutId) {
+          clearTimeout(pending.timeoutId);
+        }
+        pending.reject(new Error(message.error));
+        this.#pendingRequests.delete(message.requestID);
+      }
+    } else {
+      logger.error("Worker error: {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) => {
+      const timeoutId = setTimeout(() => {
+        if (this.#pendingRequests.has(requestID)) {
+          this.#pendingRequests.delete(requestID);
+          reject(new Error("Request timeout"));
+        }
+      }, this.#options.requestTimeout);
+      this.#pendingRequests.set(requestID, { resolve, reject, timeoutId });
+      this.#sendRequest(worker, request, requestID).catch(reject);
+    });
+  }
+  /**
+   * 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 {
-  ActivateEvent,
   BasePlatform,
-  CustomBucketStorage,
-  ExtendableEvent,
-  FetchEvent,
-  InstallEvent,
-  RequestCookieStore,
-  ServiceWorkerGlobals,
+  CustomLoggerStorage,
   ServiceWorkerPool,
-  ShovelServiceWorkerRegistration,
   SingleThreadedRuntime,
-  configureLogging,
-  createBucketFactory,
-  createCacheFactory,
   createPlatform,
   detectDeploymentPlatform,
   detectDevelopmentPlatform,
   detectRuntime,
-  getBucketConfig,
-  getCacheConfig,
   getPlatform,
   getPlatformAsync,
-  loadConfig,
-  matchPattern,
-  parseConfigExpr,
-  parseCookieHeader,
-  parseSetCookieHeader,
   platformRegistry,
-  processConfigValue,
-  resolvePlatform,
-  serializeCookie
+  resolvePlatform
 };