@b9g/platform 0.1.12 → 0.1.13

package/chunk-P57PW2II.js

@@ -1,11 +0,0 @@
-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');
-});
-
-export {
-  __require
-};

package/src/worker.d.ts

@@ -1,39 +0,0 @@
-/**
- * Worker Entry Point for MultiThreadedRuntime
- *
- * This is the explicit entry point for worker threads spawned by MultiThreadedRuntime.
- * It sets up message handling and initializes the ServiceWorker runtime.
- *
- * This file is loaded directly as a Worker script - no detection needed.
- *
- * BOOTSTRAP ORDER:
- * 1. Create placeholder caches/directories with deferred factories
- * 2. Create and install ServiceWorkerGlobals (provides `self`, `addEventListener`, etc.)
- * 3. Set up message handlers using `self.addEventListener`
- * 4. Wait for "init" message to configure factories with real config
- * 5. Wait for "load" message to load and activate ServiceWorker
- */
-import { Cache } from "@b9g/cache";
-import { type ShovelConfig } from "./runtime.js";
-export interface DirectoryFactoryOptions {
-    /** Base directory for path resolution (entrypoint directory) - REQUIRED */
-    baseDir: string;
-    /** Shovel configuration for overrides */
-    config?: ShovelConfig;
-}
-/**
- * Creates a directory factory function for CustomDirectoryStorage.
- */
-export declare function createDirectoryFactory(options: DirectoryFactoryOptions): (name: string) => Promise<FileSystemDirectoryHandle>;
-export interface CacheFactoryOptions {
-    /** Shovel configuration for cache settings */
-    config?: ShovelConfig;
-    /** Default provider when not specified in config. Defaults to "memory". */
-    defaultProvider?: string;
-    /** If true, use PostMessageCache for memory caches (for workers) */
-    usePostMessage?: boolean;
-}
-/**
- * Creates a cache factory function for CustomCacheStorage.
- */
-export declare function createCacheFactory(options?: CacheFactoryOptions): (name: string) => Promise<Cache>;

package/src/worker.js

@@ -1,285 +0,0 @@
-/// <reference types="./worker.d.ts" />
-import "../chunk-P57PW2II.js";
-
-// src/worker.ts
-import { resolve } from "path";
-import { getLogger } from "@logtape/logtape";
-import { CustomDirectoryStorage } from "@b9g/filesystem";
-import { CustomCacheStorage } from "@b9g/cache";
-import { handleCacheResponse, PostMessageCache } from "@b9g/cache/postmessage";
-import {
-  ServiceWorkerGlobals,
-  ShovelServiceWorkerRegistration,
-  CustomLoggerStorage,
-  configureLogging
-} from "./runtime.js";
-function matchPattern(name, patterns) {
-  if (!patterns)
-    return void 0;
-  if (patterns[name])
-    return patterns[name];
-  for (const [pattern, value] of Object.entries(patterns)) {
-    if (pattern.includes("*")) {
-      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
-      if (regex.test(name))
-        return value;
-    }
-  }
-  return void 0;
-}
-function getCacheConfig(config, name) {
-  return matchPattern(name, config.caches) || {};
-}
-function getDirectoryConfig(config, name) {
-  return matchPattern(name, config.directories) || {};
-}
-var WELL_KNOWN_DIRECTORY_PATHS = {
-  static: (baseDir) => resolve(baseDir, "../static"),
-  server: (baseDir) => baseDir
-};
-var BUILTIN_DIRECTORY_PROVIDERS = {
-  node: "@b9g/filesystem/node.js",
-  memory: "@b9g/filesystem/memory.js",
-  s3: "@b9g/filesystem-s3"
-};
-function createDirectoryFactory(options) {
-  const { baseDir, config } = options;
-  return async (name) => {
-    const dirConfig = config ? getDirectoryConfig(config, name) : {};
-    let dirPath;
-    if (dirConfig.path) {
-      dirPath = String(dirConfig.path);
-    } else if (WELL_KNOWN_DIRECTORY_PATHS[name]) {
-      dirPath = WELL_KNOWN_DIRECTORY_PATHS[name](baseDir);
-    } else {
-      dirPath = resolve(baseDir, `../${name}`);
-    }
-    const provider = String(dirConfig.provider || "node");
-    const modulePath = BUILTIN_DIRECTORY_PROVIDERS[provider] || provider;
-    if (modulePath === "@b9g/filesystem/node.js") {
-      const { NodeDirectory } = await import("@b9g/filesystem/node.js");
-      return new NodeDirectory(dirPath);
-    }
-    if (modulePath === "@b9g/filesystem/memory.js") {
-      const { MemoryDirectory } = await import("@b9g/filesystem/memory.js");
-      return new MemoryDirectory(name);
-    }
-    const module = await import(modulePath);
-    const DirectoryClass = module.default || module.S3Directory || module.Directory || Object.values(module).find(
-      (v) => typeof v === "function" && v.name?.includes("Directory")
-    );
-    if (!DirectoryClass) {
-      throw new Error(
-        `Directory module "${modulePath}" does not export a valid directory class.`
-      );
-    }
-    const { provider: _, path: __, ...dirOptions } = dirConfig;
-    return new DirectoryClass(name, { path: dirPath, ...dirOptions });
-  };
-}
-var BUILTIN_CACHE_PROVIDERS = {
-  memory: "@b9g/cache/memory.js",
-  redis: "@b9g/cache-redis"
-};
-function createCacheFactory(options = {}) {
-  const { config, defaultProvider = "memory", usePostMessage = false } = options;
-  return async (name) => {
-    const cacheConfig = config ? getCacheConfig(config, name) : {};
-    const provider = String(cacheConfig.provider || defaultProvider);
-    if (provider === "cloudflare") {
-      const nativeCaches = globalThis.__cloudflareCaches ?? globalThis.caches;
-      if (!nativeCaches) {
-        throw new Error(
-          "Cloudflare cache provider requires native caches API."
-        );
-      }
-      return nativeCaches.open(name);
-    }
-    if (provider === "memory" && usePostMessage) {
-      return new PostMessageCache(name);
-    }
-    const { provider: _, ...cacheOptions } = cacheConfig;
-    const modulePath = BUILTIN_CACHE_PROVIDERS[provider] || provider;
-    const module = await import(modulePath);
-    const CacheClass = module.default || module.RedisCache || module.MemoryCache || module.Cache || Object.values(module).find(
-      (v) => typeof v === "function" && v.name?.includes("Cache")
-    );
-    if (!CacheClass) {
-      throw new Error(
-        `Cache module "${modulePath}" does not export a valid cache class.`
-      );
-    }
-    return new CacheClass(name, cacheOptions);
-  };
-}
-var workerId = Math.random().toString(36).substring(2, 8);
-var resolveCacheFactory;
-var resolveDirectoryFactory;
-var cacheFactoryPromise = new Promise((resolve2) => {
-  resolveCacheFactory = resolve2;
-});
-var directoryFactoryPromise = new Promise((resolve2) => {
-  resolveDirectoryFactory = resolve2;
-});
-var caches = new CustomCacheStorage(async (name) => {
-  const factory = await cacheFactoryPromise;
-  return factory(name);
-});
-var directories = new CustomDirectoryStorage(async (name) => {
-  const factory = await directoryFactoryPromise;
-  return factory(name);
-});
-var loggers = new CustomLoggerStorage(
-  (...categories) => getLogger(categories)
-);
-var registration = new ShovelServiceWorkerRegistration();
-var scope = new ServiceWorkerGlobals({
-  registration,
-  caches,
-  directories,
-  loggers
-});
-scope.install();
-var logger = getLogger(["platform"]);
-var sendMessage;
-var serviceWorkerReady = false;
-var loadedEntrypoint = null;
-async function handleFetchEvent(request) {
-  if (!serviceWorkerReady) {
-    throw new Error("ServiceWorker not ready");
-  }
-  try {
-    return await registration.handleRequest(request);
-  } catch (error) {
-    logger.error("[Worker] ServiceWorker request failed: {error}", { error });
-    console.error("[Worker] ServiceWorker request failed:", error);
-    return new Response("ServiceWorker request failed", { status: 500 });
-  }
-}
-async function loadServiceWorker(entrypoint) {
-  try {
-    logger.debug("loadServiceWorker called", { entrypoint, loadedEntrypoint });
-    logger.info("[Worker] Loading from", { entrypoint });
-    if (loadedEntrypoint !== null && loadedEntrypoint !== entrypoint) {
-      logger.info(
-        `[Worker] Hot reload detected: ${loadedEntrypoint} -> ${entrypoint}`
-      );
-      logger.info("[Worker] Creating completely fresh ServiceWorker context");
-      registration = new ShovelServiceWorkerRegistration();
-      scope = new ServiceWorkerGlobals({
-        registration,
-        caches,
-        directories,
-        loggers
-      });
-      scope.install();
-    }
-    loadedEntrypoint = entrypoint;
-    const app = await import(entrypoint);
-    logger.debug("[Worker] ServiceWorker module loaded", {
-      exports: Object.keys(app)
-    });
-    logger.info("[Worker] Running install event");
-    await registration.install();
-    logger.info("[Worker] Running activate event");
-    await registration.activate();
-    serviceWorkerReady = true;
-    logger.info("[Worker] ServiceWorker ready", { entrypoint });
-  } catch (error) {
-    logger.error("[Worker] Failed to load ServiceWorker: {error}", {
-      error,
-      entrypoint
-    });
-    serviceWorkerReady = false;
-    throw error;
-  }
-}
-async function initializeRuntime(config, baseDir) {
-  try {
-    if (config?.logging) {
-      await configureLogging(config.logging, { reset: true });
-    }
-    logger.info(`[Worker-${workerId}] Initializing runtime`, { config, baseDir });
-    logger.info(`[Worker-${workerId}] Configuring cache factory`);
-    resolveCacheFactory(createCacheFactory({ config, usePostMessage: true }));
-    logger.info(`[Worker-${workerId}] Configuring directory factory`);
-    resolveDirectoryFactory(createDirectoryFactory({ baseDir, config }));
-    logger.info(`[Worker-${workerId}] Runtime initialized successfully`);
-  } catch (error) {
-    logger.error(`[Worker-${workerId}] Failed to initialize runtime: {error}`, {
-      error
-    });
-    throw error;
-  }
-}
-async function handleMessage(message) {
-  try {
-    logger.info(`[Worker-${workerId}] Received message`, { type: message.type });
-    if (message.type === "init") {
-      const initMsg = message;
-      await initializeRuntime(initMsg.config, initMsg.baseDir);
-      logger.info(`[Worker-${workerId}] Sending initialized message`);
-      sendMessage({ type: "initialized" });
-    } else if (message.type === "load") {
-      const loadMsg = message;
-      await loadServiceWorker(loadMsg.entrypoint);
-      sendMessage({ type: "ready", entrypoint: loadMsg.entrypoint });
-    } else if (message.type === "request") {
-      const reqMsg = message;
-      const request = new Request(reqMsg.request.url, {
-        method: reqMsg.request.method,
-        headers: reqMsg.request.headers,
-        body: reqMsg.request.body
-      });
-      const response = await handleFetchEvent(request);
-      const body = await response.arrayBuffer();
-      const headers = Object.fromEntries(response.headers.entries());
-      if (!headers["Content-Type"] && !headers["content-type"]) {
-        headers["Content-Type"] = "text/plain; charset=utf-8";
-      }
-      const responseMsg = {
-        type: "response",
-        response: {
-          status: response.status,
-          statusText: response.statusText,
-          headers,
-          body
-        },
-        requestID: reqMsg.requestID
-      };
-      sendMessage(responseMsg, [body]);
-    }
-  } catch (error) {
-    const errorMsg = {
-      type: "error",
-      error: error instanceof Error ? error.message : String(error),
-      stack: error instanceof Error ? error.stack : void 0,
-      requestID: message.requestID
-    };
-    sendMessage(errorMsg);
-  }
-}
-self.addEventListener("message", (event) => {
-  const msg = event.data;
-  if (msg?.type === "cache:response" || msg?.type === "cache:error") {
-    logger.debug(`[Worker-${workerId}] Forwarding cache message`, {
-      type: msg.type,
-      requestID: msg.requestID
-    });
-    handleCacheResponse(msg);
-    return;
-  }
-  void handleMessage(event.data);
-});
-sendMessage = (message, transfer) => {
-  if (transfer && transfer.length > 0) {
-    postMessage(message, transfer);
-  } else {
-    postMessage(message);
-  }
-};
-sendMessage({ type: "worker-ready" });
-export {
-  createCacheFactory,
-  createDirectoryFactory
-};