@b9g/platform 0.1.11 → 0.1.12

package/src/shovel-config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Type declarations for the shovel:config virtual module.
+ * This module is resolved by esbuild at build time.
+ */
+declare module "shovel:config" {
+	import type {ShovelConfig} from "./runtime.js";
+
+	export const config: ShovelConfig;
+	export type {ShovelConfig};
+}

package/src/worker.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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

@@ -0,0 +1,285 @@
+/// <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
+};

package/src/config.d.ts

@@ -1,172 +0,0 @@
-/**
- * Configuration expression parser
- *
- * Embeddable JavaScript-like expressions for JSON config:
- * - ALL_CAPS = env var reference (e.g., NODE_ENV, PORT)
- * - Everything else = string literal (kebab-case, URLs, camelCase, PascalCase)
- * - Quoted strings = explicit strings (escape hatch)
- * - JavaScript keywords: true, false, null, undefined
- * - Operators: ||, &&, ===, !==, ==, !=, ? :, !
- * - No eval - uses recursive descent parser
- *
- * Examples:
- *   "PORT || 3000"
- *   "NODE_ENV === production ? redis : memory"
- *   "REDIS_URL || redis://localhost:6379"
- *   "S3_BUCKET || my-bucket-name"
- *   "BASE_PATH || ./uploads"
- */
-import { Cache } from "@b9g/cache";
-/**
- * Parse a configuration expression with the DSL
- */
-export declare function parseConfigExpr(expr: string, env?: Record<string, string | undefined>, options?: {
-    strict?: boolean;
-}): any;
-/**
- * Process a config value (handles nested objects/arrays)
- */
-export declare function processConfigValue(value: any, env?: Record<string, string | undefined>, options?: {
-    strict?: boolean;
-}): any;
-/**
- * Match a name against config patterns
- *
- * Priority:
- * 1. Exact match: "sessions" matches "sessions"
- * 2. Prefix patterns: "api-*" matches "api-v1", "api-v2" (longest first)
- * 3. Catch-all: "*" matches everything
- *
- * Examples:
- *   matchPattern("sessions", {"sessions": {...}, "*": {...}})  → sessions config
- *   matchPattern("api-v1", {"api-*": {...}, "*": {...}})       → api-* config
- *   matchPattern("random", {"*": {...}})                        → * config
- */
-export declare function matchPattern<T>(name: string, config: Record<string, T>): T | undefined;
-export interface CacheConfig {
-    provider?: string | number;
-    url?: string | number;
-    maxEntries?: string | number;
-    TTL?: string | number;
-}
-export interface BucketConfig {
-    provider?: string | number;
-    path?: string | number;
-    bucket?: string | number;
-    region?: string | number;
-    endpoint?: string | number;
-}
-/** Log level for filtering */
-export type LogLevel = "debug" | "info" | "warning" | "error";
-/** Sink configuration */
-export interface SinkConfig {
-    provider: string;
-    /** Provider-specific options (path, maxSize, etc.) */
-    [key: string]: any;
-}
-/** Per-category logging configuration */
-export interface CategoryLoggingConfig {
-    level?: LogLevel;
-    sinks?: SinkConfig[];
-}
-export interface LoggingConfig {
-    /** Default log level. Defaults to "info" */
-    level?: LogLevel;
-    /** Default sinks. Defaults to console */
-    sinks?: SinkConfig[];
-    /** Per-category config (inherits from top-level, can override level and/or sinks) */
-    categories?: Record<string, CategoryLoggingConfig>;
-}
-export interface ShovelConfig {
-    platform?: string;
-    port?: number | string;
-    host?: string;
-    workers?: number | string;
-    logging?: LoggingConfig;
-    caches?: Record<string, CacheConfig>;
-    buckets?: Record<string, BucketConfig>;
-}
-/** Processed logging config with all defaults applied */
-export interface ProcessedLoggingConfig {
-    level: LogLevel;
-    sinks: SinkConfig[];
-    categories: Record<string, CategoryLoggingConfig>;
-}
-export interface ProcessedShovelConfig {
-    platform?: string;
-    port: number;
-    host: string;
-    workers: number;
-    logging: ProcessedLoggingConfig;
-    caches: Record<string, CacheConfig>;
-    buckets: Record<string, BucketConfig>;
-}
-/**
- * Load Shovel configuration from shovel.json or package.json
- * Priority: shovel.json > package.json "shovel" field > defaults
- * @param cwd - Current working directory (must be provided by runtime adapter)
- */
-export declare function loadConfig(cwd: string): ProcessedShovelConfig;
-/**
- * Configure LogTape logging based on Shovel config.
- * Call this in both main thread and workers.
- *
- * @param loggingConfig - The logging configuration from ProcessedShovelConfig.logging
- * @param options - Additional options
- * @param options.reset - Whether to reset existing LogTape config (default: true)
- * @param options.cwd - Working directory for resolving relative paths
- */
-export declare function configureLogging(loggingConfig: ProcessedLoggingConfig, options?: {
-    reset?: boolean;
-    cwd?: string;
-}): Promise<void>;
-/**
- * Get cache config for a specific cache name (with pattern matching)
- */
-export declare function getCacheConfig(config: ProcessedShovelConfig, name: string): CacheConfig;
-/**
- * Get bucket config for a specific bucket name (with pattern matching)
- */
-export declare function getBucketConfig(config: ProcessedShovelConfig, name: string): BucketConfig;
-export interface BucketFactoryOptions {
-    /** Base directory for path resolution (entrypoint directory) - REQUIRED */
-    baseDir: string;
-    /** Shovel configuration for overrides */
-    config?: ProcessedShovelConfig;
-}
-/**
- * Creates a bucket factory function for CustomBucketStorage.
- * Lazily imports bucket implementations.
- *
- * Provider resolution:
- * 1. "node" -> built-in NodeBucket (default)
- * 2. "memory" -> built-in MemoryBucket
- * 3. "s3" -> @b9g/filesystem-s3 (blessed module)
- * 4. Any other string -> treated as a module name (e.g., "my-custom-bucket")
- *
- * Custom bucket modules must export a class that:
- * - Implements FileSystemDirectoryHandle
- * - Has constructor(name: string, options?: object)
- */
-export declare function createBucketFactory(options: BucketFactoryOptions): (name: string) => Promise<FileSystemDirectoryHandle>;
-export interface CacheFactoryOptions {
-    /** Shovel configuration for cache settings */
-    config?: ProcessedShovelConfig;
-    /** Default provider when not specified in config. Defaults to "memory". */
-    defaultProvider?: string;
-}
-/**
- * Creates a cache factory function for CustomCacheStorage.
- * Lazily imports cache implementations.
- *
- * Provider resolution:
- * 1. "memory" -> built-in MemoryCache
- * 2. "redis" -> @b9g/cache-redis (blessed module)
- * 3. "cloudflare" -> native Cloudflare caches.open(name)
- * 4. Any other string -> treated as a module name (e.g., "my-custom-cache")
- *
- * Custom cache modules must export a class that:
- * - Extends Cache (from @b9g/cache)
- * - Has constructor(name: string, options?: object)
- */
-export declare function createCacheFactory(options?: CacheFactoryOptions): (name: string) => Promise<Cache>;