@b9g/platform 0.1.9 → 0.1.11

package/chunk-P57PW2II.js

@@ -0,0 +1,11 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "ServiceWorker-first universal deployment platform. Write ServiceWorker apps once, deploy anywhere (Node/Bun/Cloudflare). Registry-based multi-app orchestration.",
   "keywords": [
     "serviceworker",
@@ -15,15 +15,39 @@
     "shovel"
   ],
   "dependencies": {
-    "@b9g/async-context": "^0.1.1",
-    "@b9g/cache": "^0.1.4",
-    "@b9g/filesystem": "^0.1.6",
+    "@b9g/async-context": "^0.1.4",
+    "@b9g/cache": "^0.1.5",
+    "@b9g/filesystem": "^0.1.7",
     "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {
-    "@b9g/libuild": "^0.1.11",
+    "@b9g/libuild": "^0.1.18",
     "bun-types": "latest"
   },
+  "peerDependencies": {
+    "@logtape/file": "^1.0.0",
+    "@logtape/otel": "^1.0.0",
+    "@logtape/sentry": "^1.0.0",
+    "@logtape/syslog": "^1.0.0",
+    "@logtape/cloudwatch-logs": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@logtape/file": {
+      "optional": true
+    },
+    "@logtape/otel": {
+      "optional": true
+    },
+    "@logtape/sentry": {
+      "optional": true
+    },
+    "@logtape/syslog": {
+      "optional": true
+    },
+    "@logtape/cloudwatch-logs": {
+      "optional": true
+    }
+  },
   "type": "module",
   "types": "src/index.d.ts",
   "module": "src/index.js",

package/src/config.d.ts

@@ -56,17 +56,48 @@ export interface BucketConfig {
     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>;
 }
@@ -76,6 +107,19 @@ export interface ProcessedShovelConfig {
  * @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)
  */
@@ -108,6 +152,8 @@ export declare function createBucketFactory(options: BucketFactoryOptions): (nam
 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.
@@ -116,7 +162,8 @@ export interface CacheFactoryOptions {
  * Provider resolution:
  * 1. "memory" -> built-in MemoryCache
  * 2. "redis" -> @b9g/cache-redis (blessed module)
- * 3. Any other string -> treated as a module name (e.g., "my-custom-cache")
+ * 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)

package/src/config.js

@@ -1,8 +1,11 @@
 /// <reference types="./config.d.ts" />
+import "../chunk-P57PW2II.js";
+
 // src/config.ts
 import { readFileSync } from "fs";
 import { resolve } from "path";
 import { Cache } from "@b9g/cache";
+import { configure } from "@logtape/logtape";
 function getEnv() {
   if (typeof import.meta !== "undefined" && import.meta.env) {
     return import.meta.env;
@@ -391,15 +394,131 @@ function loadConfig(cwd) {
   const processed = processConfigValue(rawConfig, env, {
     strict: true
   });
+  const defaultSinks = [{ provider: "console" }];
   const config = {
+    platform: processed.platform,
     port: typeof processed.port === "number" ? processed.port : 3e3,
     host: processed.host || "localhost",
     workers: typeof processed.workers === "number" ? processed.workers : 1,
+    logging: {
+      level: processed.logging?.level || "info",
+      sinks: processed.logging?.sinks || defaultSinks,
+      categories: processed.logging?.categories || {}
+    },
     caches: processed.caches || {},
     buckets: processed.buckets || {}
   };
   return config;
 }
+var SHOVEL_CATEGORIES = [
+  "cli",
+  "watcher",
+  "worker",
+  "single-threaded",
+  "assets",
+  "platform-node",
+  "platform-bun",
+  "platform-cloudflare",
+  "cache",
+  "cache-redis",
+  "router"
+];
+var BUILTIN_SINK_PROVIDERS = {
+  console: { module: "@logtape/logtape", factory: "getConsoleSink" },
+  file: { module: "@logtape/file", factory: "getFileSink" },
+  rotating: { module: "@logtape/file", factory: "getRotatingFileSink" },
+  "stream-file": { module: "@logtape/file", factory: "getStreamFileSink" },
+  otel: { module: "@logtape/otel", factory: "getOpenTelemetrySink" },
+  sentry: { module: "@logtape/sentry", factory: "getSentrySink" },
+  syslog: { module: "@logtape/syslog", factory: "getSyslogSink" },
+  cloudwatch: {
+    module: "@logtape/cloudwatch-logs",
+    factory: "getCloudWatchLogsSink"
+  }
+};
+async function createSink(config, options = {}) {
+  const { provider, ...sinkOptions } = config;
+  if (sinkOptions.path && options.cwd) {
+    sinkOptions.path = resolve(options.cwd, sinkOptions.path);
+  }
+  const builtin = BUILTIN_SINK_PROVIDERS[provider];
+  const modulePath = builtin?.module || provider;
+  const factoryName = builtin?.factory || "default";
+  const module = await import(modulePath);
+  const factory = module[factoryName] || module.default;
+  if (!factory) {
+    throw new Error(
+      `Sink module "${modulePath}" has no export "${factoryName}"`
+    );
+  }
+  return factory(sinkOptions);
+}
+async function configureLogging(loggingConfig, options = {}) {
+  const { level, sinks: defaultSinkConfigs, categories } = loggingConfig;
+  const reset = options.reset !== false;
+  const allSinkConfigs = /* @__PURE__ */ new Map();
+  const sinkNameMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < defaultSinkConfigs.length; i++) {
+    const config = defaultSinkConfigs[i];
+    const name = `sink_${i}`;
+    allSinkConfigs.set(name, config);
+    sinkNameMap.set(config, name);
+  }
+  let sinkIndex = defaultSinkConfigs.length;
+  for (const [_, categoryConfig] of Object.entries(categories)) {
+    if (categoryConfig.sinks) {
+      for (const config of categoryConfig.sinks) {
+        let found = false;
+        for (const [existingConfig, _name] of sinkNameMap) {
+          if (JSON.stringify(existingConfig) === JSON.stringify(config)) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          const name = `sink_${sinkIndex++}`;
+          allSinkConfigs.set(name, config);
+          sinkNameMap.set(config, name);
+        }
+      }
+    }
+  }
+  const sinks = {};
+  for (const [name, config] of allSinkConfigs) {
+    sinks[name] = await createSink(config, { cwd: options.cwd });
+  }
+  const getSinkNames = (configs) => {
+    return configs.map((config) => {
+      for (const [existingConfig, name] of sinkNameMap) {
+        if (JSON.stringify(existingConfig) === JSON.stringify(config)) {
+          return name;
+        }
+      }
+      return "";
+    }).filter(Boolean);
+  };
+  const defaultSinkNames = getSinkNames(defaultSinkConfigs);
+  const loggers = SHOVEL_CATEGORIES.map((category) => {
+    const categoryConfig = categories[category];
+    const categoryLevel = categoryConfig?.level || level;
+    const categorySinks = categoryConfig?.sinks ? getSinkNames(categoryConfig.sinks) : defaultSinkNames;
+    return {
+      category: [category],
+      level: categoryLevel,
+      sinks: categorySinks
+    };
+  });
+  loggers.push({
+    category: ["logtape", "meta"],
+    level: "warning",
+    sinks: []
+  });
+  await configure({
+    reset,
+    sinks,
+    loggers
+  });
+}
 function getCacheConfig(config, name) {
   return matchPattern(name, config.caches) || {};
 }
@@ -468,21 +587,26 @@ var BUILTIN_CACHE_PROVIDERS = {
   redis: "@b9g/cache-redis"
 };
 function createCacheFactory(options = {}) {
-  const { config } = options;
+  const { config, defaultProvider = "memory" } = options;
   return async (name) => {
     const cacheConfig = config ? getCacheConfig(config, name) : {};
-    const provider = String(cacheConfig.provider || "memory");
-    const modulePath = BUILTIN_CACHE_PROVIDERS[provider] || provider;
-    if (modulePath === "@b9g/cache/memory.js") {
-      const { MemoryCache } = await import("@b9g/cache/memory.js");
-      return new MemoryCache(name, {
-        maxEntries: typeof cacheConfig.maxEntries === "number" ? cacheConfig.maxEntries : 1e3
-      });
+    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. This provider only works in Cloudflare Workers environment."
+        );
+      }
+      return nativeCaches.open(name);
     }
+    const { provider: _, ...cacheOptions } = cacheConfig;
+    const modulePath = BUILTIN_CACHE_PROVIDERS[provider] || provider;
     try {
       const module = await import(modulePath);
       const CacheClass = module.default || // Default export
       module.RedisCache || // Named export for redis
+      module.MemoryCache || // Named export for memory
       module.Cache || // Generic Cache export
       Object.values(module).find(
         (v) => typeof v === "function" && v.prototype instanceof Cache
@@ -492,7 +616,6 @@ function createCacheFactory(options = {}) {
           `Cache module "${modulePath}" does not export a valid cache class. Expected a default export or named export (RedisCache, Cache) that extends Cache.`
         );
       }
-      const { provider: _, ...cacheOptions } = cacheConfig;
       return new CacheClass(name, cacheOptions);
     } catch (error) {
       if (error.code === "ERR_MODULE_NOT_FOUND" || error.code === "MODULE_NOT_FOUND") {
@@ -506,6 +629,7 @@ For redis: npm install @b9g/cache-redis`
   };
 }
 export {
+  configureLogging,
   createBucketFactory,
   createCacheFactory,
   getBucketConfig,

package/src/cookie-store.js

@@ -1,4 +1,6 @@
 /// <reference types="./cookie-store.d.ts" />
+import "../chunk-P57PW2II.js";
+
 // src/cookie-store.ts
 function parseCookieHeader(cookieHeader) {
   const cookies = /* @__PURE__ */ new Map();

package/src/index.d.ts

@@ -134,16 +134,20 @@ export declare function detectDeploymentPlatform(): string | null;
  */
 export declare function detectDevelopmentPlatform(): string;
 /**
- * Resolve platform name from options or auto-detect
+ * Resolve platform name from options, config, or auto-detect
  *
  * Priority:
- * 1. Explicit --platform or --target flag
- * 2. Deployment platform detection (production environments)
- * 3. Development platform detection (local runtime)
+ * 1. Explicit --platform or --target CLI flag
+ * 2. shovel.json or package.json "shovel.platform" field
+ * 3. Deployment platform detection (production environments)
+ * 4. Development platform detection (local runtime)
  */
 export declare function resolvePlatform(options: {
     platform?: string;
     target?: string;
+    config?: {
+        platform?: string;
+    };
 }): string;
 /**
  * Create platform instance based on name
@@ -189,7 +193,7 @@ export declare function getPlatform(name?: string): Platform;
 export declare function getPlatformAsync(name?: string): Promise<Platform>;
 export { ServiceWorkerPool, type WorkerPoolOptions, type WorkerMessage, type WorkerRequest, type WorkerResponse, type WorkerLoadMessage, type WorkerReadyMessage, type WorkerErrorMessage, type WorkerInitMessage, type WorkerInitializedMessage, } from "./worker-pool.js";
 export { SingleThreadedRuntime, type SingleThreadedRuntimeOptions, } from "./single-threaded.js";
-export { ShovelServiceWorkerRegistration, ShovelGlobalScope, FetchEvent, InstallEvent, ActivateEvent, ExtendableEvent, } from "./runtime.js";
+export { ShovelServiceWorkerRegistration, ServiceWorkerGlobals, FetchEvent, InstallEvent, ActivateEvent, ExtendableEvent, } from "./runtime.js";
 export { RequestCookieStore, type CookieListItem, type CookieInit, type CookieStoreGetOptions, type CookieStoreDeleteOptions, type CookieSameSite, type CookieList, parseCookieHeader, serializeCookie, parseSetCookieHeader, } from "./cookie-store.js";
 export { CustomBucketStorage } from "@b9g/filesystem";
-export { loadConfig, getCacheConfig, getBucketConfig, parseConfigExpr, processConfigValue, matchPattern, createBucketFactory, createCacheFactory, type ShovelConfig, type CacheConfig, type BucketConfig, type BucketFactoryOptions, type CacheFactoryOptions, type ProcessedShovelConfig, } from "./config.js";
+export { loadConfig, configureLogging, getCacheConfig, getBucketConfig, parseConfigExpr, processConfigValue, matchPattern, createBucketFactory, createCacheFactory, type ShovelConfig, type CacheConfig, type BucketConfig, type LoggingConfig, type LogLevel, type BucketFactoryOptions, type CacheFactoryOptions, type ProcessedShovelConfig, } from "./config.js";

package/src/index.js

@@ -1,4 +1,6 @@
 /// <reference types="./index.d.ts" />
+import "../chunk-P57PW2II.js";
+
 // src/index.ts
 import * as Path from "path";
 import { readFileSync } from "fs";
@@ -12,7 +14,7 @@ import {
 } from "./single-threaded.js";
 import {
   ShovelServiceWorkerRegistration,
-  ShovelGlobalScope,
+  ServiceWorkerGlobals,
   FetchEvent,
   InstallEvent,
   ActivateEvent,
@@ -27,6 +29,7 @@ import {
 import { CustomBucketStorage } from "@b9g/filesystem";
 import {
   loadConfig,
+  configureLogging,
   getCacheConfig,
   getBucketConfig,
   parseConfigExpr,
@@ -54,7 +57,10 @@ function detectPlatformFromPackageJSON(cwd) {
     const pkg = JSON.parse(pkgContent);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     return selectPlatformFromDeps(deps);
-  } catch {
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
     return null;
   }
 }
@@ -121,6 +127,9 @@ function resolvePlatform(options) {
   if (options.target) {
     return options.target;
   }
+  if (options.config?.platform) {
+    return options.config.platform;
+  }
   const deploymentPlatform = detectDeploymentPlatform();
   if (deploymentPlatform) {
     return deploymentPlatform;
@@ -233,10 +242,11 @@ export {
   FetchEvent,
   InstallEvent,
   RequestCookieStore,
+  ServiceWorkerGlobals,
   ServiceWorkerPool,
-  ShovelGlobalScope,
   ShovelServiceWorkerRegistration,
   SingleThreadedRuntime,
+  configureLogging,
   createBucketFactory,
   createCacheFactory,
   createPlatform,

package/src/runtime.d.ts

@@ -4,7 +4,7 @@
  * This module provides the complete ServiceWorker runtime environment for Shovel:
  * - Base Event Classes (ExtendableEvent, FetchEvent, InstallEvent, ActivateEvent)
  * - ServiceWorker API Type Shims (Client, Clients, ServiceWorkerRegistration, etc.)
- * - ShovelGlobalScope (implements ServiceWorkerGlobalScope for any JavaScript runtime)
+ * - ServiceWorkerGlobals (installs ServiceWorker globals onto any JavaScript runtime)
  *
  * Based on: https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API#interfaces
  */
@@ -330,7 +330,7 @@ interface NotificationOptions {
     timestamp?: number;
     vibrate?: number[];
 }
-export interface ShovelGlobalScopeOptions {
+export interface ServiceWorkerGlobalsOptions {
     /** ServiceWorker registration instance */
     registration: ServiceWorkerRegistration;
     /** Bucket storage (file system access) - REQUIRED */
@@ -353,12 +353,15 @@ export declare class WorkerGlobalScope {
 export declare class DedicatedWorkerGlobalScope extends WorkerGlobalScope {
 }
 /**
- * ShovelGlobalScope implements ServiceWorkerGlobalScope
+ * ServiceWorkerGlobals - Installs ServiceWorker globals onto globalThis
  *
- * This is the `self` object in Shovel ServiceWorker applications.
- * It provides all standard ServiceWorker APIs plus Shovel-specific extensions.
+ * This class holds ServiceWorker API implementations (caches, buckets, clients, etc.)
+ * and patches them onto globalThis via install(). It maintains the browser invariant
+ * that self === globalThis while providing ServiceWorker APIs.
+ *
+ * Use restore() to revert all patches (useful for testing).
  */
-export declare class ShovelGlobalScope implements ServiceWorkerGlobalScope {
+export declare class ServiceWorkerGlobals implements ServiceWorkerGlobalScope {
     #private;
     readonly self: any;
     readonly registration: ServiceWorkerRegistration;
@@ -405,7 +408,7 @@ export declare class ShovelGlobalScope implements ServiceWorkerGlobalScope {
     ononline: ((ev: Event) => any) | null;
     onrejectionhandled: ((ev: PromiseRejectionEvent) => any) | null;
     onunhandledrejection: ((ev: PromiseRejectionEvent) => any) | null;
-    constructor(options: ShovelGlobalScopeOptions);
+    constructor(options: ServiceWorkerGlobalsOptions);
     /**
      * Standard ServiceWorker skipWaiting() implementation
      * Allows the ServiceWorker to activate immediately
@@ -419,8 +422,13 @@ export declare class ShovelGlobalScope implements ServiceWorkerGlobalScope {
     dispatchEvent(event: Event): boolean;
     /**
      * Install this scope as the global scope
-     * Sets up globalThis with all ServiceWorker globals
+     * Patches globalThis with ServiceWorker globals while maintaining self === globalThis
      */
     install(): void;
+    /**
+     * Restore original globals (for testing)
+     * Reverts all patched globals to their original values
+     */
+    restore(): void;
 }
 export {};

package/src/runtime.js

@@ -1,4 +1,6 @@
 /// <reference types="./runtime.d.ts" />
+import "../chunk-P57PW2II.js";
+
 // src/runtime.ts
 import { RequestCookieStore } from "./cookie-store.js";
 import { AsyncContext } from "@b9g/async-context";
@@ -6,10 +8,28 @@ import { CustomBucketStorage } from "@b9g/filesystem";
 import { CustomCacheStorage } from "@b9g/cache";
 import { createBucketFactory, createCacheFactory } from "./config.js";
 import { getLogger } from "@logtape/logtape";
+import { configureLogging } from "./config.js";
 if (import.meta.env && !import.meta.env.MODE && import.meta.env.NODE_ENV) {
   import.meta.env.MODE = import.meta.env.NODE_ENV;
 }
 var cookieStoreStorage = new AsyncContext.Variable();
+var fetchDepthStorage = new AsyncContext.Variable();
+var MAX_FETCH_DEPTH = 10;
+var PATCHED_KEYS = [
+  "self",
+  "fetch",
+  "caches",
+  "buckets",
+  "registration",
+  "clients",
+  "skipWaiting",
+  "addEventListener",
+  "removeEventListener",
+  "dispatchEvent",
+  "WorkerGlobalScope",
+  "DedicatedWorkerGlobalScope",
+  "cookieStore"
+];
 function promiseWithTimeout(promise, timeoutMs, errorMessage) {
   return Promise.race([
     promise,
@@ -608,7 +628,7 @@ var WorkerGlobalScope = class {
 };
 var DedicatedWorkerGlobalScope = class extends WorkerGlobalScope {
 };
-var ShovelGlobalScope = class {
+var ServiceWorkerGlobals = class {
   // Self-reference (standard in ServiceWorkerGlobalScope)
   // Type assertion: we provide a compatible subset of WorkerGlobalScope
   self;
@@ -623,6 +643,8 @@ var ShovelGlobalScope = class {
   clients;
   // Shovel-specific development features
   #isDevelopment;
+  // Snapshot of original globals before patching (for restore())
+  #originals;
   // Web API required properties
   // Note: Using RequestCookieStore but typing as any for flexibility with global CookieStore type
   // cookieStore is retrieved from AsyncContext for per-request isolation
@@ -664,7 +686,22 @@ var ShovelGlobalScope = class {
     );
   }
   fetch(input, init) {
-    return globalThis.fetch(input, init);
+    const urlString = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const isRelative = urlString.startsWith("/") || urlString.startsWith("./");
+    if (!isRelative) {
+      const originalFetch = this.#originals.fetch;
+      return originalFetch(input, init);
+    }
+    const currentDepth = fetchDepthStorage.get() ?? 0;
+    if (currentDepth >= MAX_FETCH_DEPTH) {
+      return Promise.reject(
+        new Error(`Maximum self-fetch depth (${MAX_FETCH_DEPTH}) exceeded`)
+      );
+    }
+    const request = new Request(new URL(urlString, "http://localhost"), init);
+    return fetchDepthStorage.run(currentDepth + 1, () => {
+      return this.registration.handleRequest(request);
+    });
   }
   queueMicrotask(callback) {
     globalThis.queueMicrotask(callback);
@@ -702,7 +739,12 @@ var ShovelGlobalScope = class {
   onrejectionhandled;
   onunhandledrejection;
   constructor(options) {
-    this.self = this;
+    const g = globalThis;
+    this.#originals = {};
+    for (const key of PATCHED_KEYS) {
+      this.#originals[key] = g[key];
+    }
+    this.self = globalThis;
     this.registration = options.registration;
     this.caches = options.caches;
     this.buckets = options.buckets;
@@ -773,28 +815,43 @@ var ShovelGlobalScope = class {
   }
   /**
    * Install this scope as the global scope
-   * Sets up globalThis with all ServiceWorker globals
+   * Patches globalThis with ServiceWorker globals while maintaining self === globalThis
    */
   install() {
-    globalThis.WorkerGlobalScope = WorkerGlobalScope;
-    globalThis.DedicatedWorkerGlobalScope = DedicatedWorkerGlobalScope;
-    globalThis.self = this;
-    const isWorker = "onmessage" in globalThis;
-    if (isWorker && typeof postMessage === "function") {
-      this.postMessage = postMessage.bind(globalThis);
-    }
-    globalThis.addEventListener = this.addEventListener.bind(this);
-    globalThis.removeEventListener = this.removeEventListener.bind(this);
-    globalThis.dispatchEvent = this.dispatchEvent.bind(this);
-    if (this.caches) {
-      globalThis.caches = this.caches;
+    const g = globalThis;
+    g.WorkerGlobalScope = WorkerGlobalScope;
+    g.DedicatedWorkerGlobalScope = DedicatedWorkerGlobalScope;
+    if (typeof g.self === "undefined") {
+      g.self = globalThis;
     }
-    if (this.buckets) {
-      globalThis.buckets = this.buckets;
+    g.addEventListener = this.addEventListener.bind(this);
+    g.removeEventListener = this.removeEventListener.bind(this);
+    g.dispatchEvent = this.dispatchEvent.bind(this);
+    g.caches = this.caches;
+    g.buckets = this.buckets;
+    g.registration = this.registration;
+    g.skipWaiting = this.skipWaiting.bind(this);
+    g.clients = this.clients;
+    g.fetch = this.fetch.bind(this);
+    Object.defineProperty(g, "cookieStore", {
+      get: () => cookieStoreStorage.get(),
+      configurable: true
+    });
+  }
+  /**
+   * Restore original globals (for testing)
+   * Reverts all patched globals to their original values
+   */
+  restore() {
+    const g = globalThis;
+    for (const key of PATCHED_KEYS) {
+      const original = this.#originals[key];
+      if (original === void 0) {
+        delete g[key];
+      } else {
+        g[key] = original;
+      }
     }
-    globalThis.registration = this.registration;
-    globalThis.skipWaiting = this.skipWaiting.bind(this);
-    globalThis.clients = this.clients;
   }
 };
 var logger = getLogger(["worker"]);
@@ -831,7 +888,7 @@ async function handleFetchEvent(request) {
     const response = await registration.handleRequest(request);
     return response;
   } catch (error) {
-    logger.error("[Worker] ServiceWorker request failed", { error });
+    logger.error("[Worker] ServiceWorker request failed: {error}", { error });
     console.error("[Worker] ServiceWorker request failed:", error);
     const response = new Response("ServiceWorker request failed", {
       status: 500
@@ -855,7 +912,7 @@ async function loadServiceWorker(entrypoint) {
       if (!caches || !buckets) {
         throw new Error("Runtime not initialized - missing caches or buckets");
       }
-      scope = new ShovelGlobalScope({
+      scope = new ServiceWorkerGlobals({
         registration,
         caches,
         buckets
@@ -899,6 +956,9 @@ var workerId = Math.random().toString(36).substring(2, 8);
 var sendMessage;
 async function initializeRuntime(config, baseDir) {
   try {
+    if (config?.logging) {
+      await configureLogging(config.logging);
+    }
     logger.info(`[Worker-${workerId}] Initializing runtime with config`, {
       config,
       baseDir
@@ -909,7 +969,7 @@ async function initializeRuntime(config, baseDir) {
     buckets = new CustomBucketStorage(createBucketFactory({ baseDir, config }));
     logger.info(`[Worker-${workerId}] Creating and installing scope`);
     registration = new ShovelServiceWorkerRegistration();
-    scope = new ShovelGlobalScope({ registration, caches, buckets });
+    scope = new ServiceWorkerGlobals({ registration, caches, buckets });
     scope.install();
     _workerSelf = scope;
     logger.info(`[Worker-${workerId}] Runtime initialized successfully`);
@@ -983,9 +1043,9 @@ export {
   Notification,
   NotificationEvent,
   PushEvent,
+  ServiceWorkerGlobals,
   ShovelClient,
   ShovelClients,
-  ShovelGlobalScope,
   ShovelNavigationPreloadManager,
   ShovelPushMessageData,
   ShovelServiceWorker,

package/src/single-threaded.d.ts

@@ -26,7 +26,7 @@ export declare class SingleThreadedRuntime {
     #private;
     constructor(options: SingleThreadedRuntimeOptions);
     /**
-     * Initialize the runtime (install scope as globalThis.self)
+     * Initialize the runtime (install ServiceWorker globals)
      */
     init(): Promise<void>;
     /**

package/src/single-threaded.js

@@ -1,10 +1,16 @@
 /// <reference types="./single-threaded.d.ts" />
+import "../chunk-P57PW2II.js";
+
 // src/single-threaded.ts
 import { getLogger } from "@logtape/logtape";
-import { ShovelGlobalScope, ShovelServiceWorkerRegistration } from "./runtime.js";
+import {
+  ServiceWorkerGlobals,
+  ShovelServiceWorkerRegistration
+} from "./runtime.js";
 import { CustomBucketStorage } from "@b9g/filesystem";
 import { CustomCacheStorage } from "@b9g/cache";
 import {
+  configureLogging,
   createBucketFactory,
   createCacheFactory
 } from "./config.js";
@@ -23,7 +29,7 @@ var SingleThreadedRuntime = class {
       createBucketFactory({ baseDir: options.baseDir, config: options.config })
     );
     this.#registration = new ShovelServiceWorkerRegistration();
-    this.#scope = new ShovelGlobalScope({
+    this.#scope = new ServiceWorkerGlobals({
       registration: this.#registration,
       caches: cacheStorage,
       buckets: bucketStorage
@@ -31,11 +37,14 @@ var SingleThreadedRuntime = class {
     logger.info("SingleThreadedRuntime created", { baseDir: options.baseDir });
   }
   /**
-   * Initialize the runtime (install scope as globalThis.self)
+   * Initialize the runtime (install ServiceWorker globals)
    */
   async init() {
+    if (this.#config?.logging) {
+      await configureLogging(this.#config.logging);
+    }
     this.#scope.install();
-    logger.info("SingleThreadedRuntime initialized - scope installed");
+    logger.info("SingleThreadedRuntime initialized - globals installed");
   }
   /**
    * Load and run a ServiceWorker entrypoint

package/src/worker-pool.js

@@ -1,11 +1,7 @@
 /// <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');
-});
+import {
+  __require
+} from "../chunk-P57PW2II.js";
 
 // src/worker-pool.ts
 import * as Path from "path";
@@ -29,7 +25,10 @@ function resolveWorkerScript(entrypoint) {
           return bundledWorker;
         }
       }
-    } catch {
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
     }
   }
   try {
@@ -246,7 +245,7 @@ var ServiceWorkerPool = class {
         this.#pendingRequests.delete(message.requestID);
       }
     } else {
-      logger.error("Worker error", { error: message.error });
+      logger.error("Worker error: {error}", { error: message.error });
     }
   }
   #handleReady(message) {