@b9g/platform 0.1.10 → 0.1.12

package/src/runtime.js

@@ -1,16 +1,251 @@
 /// <reference types="./runtime.d.ts" />
+import "../chunk-P57PW2II.js";
+
 // src/runtime.ts
-import { RequestCookieStore } from "./cookie-store.js";
 import { AsyncContext } from "@b9g/async-context";
-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";
+import {
+  configure
+} from "@logtape/logtape";
+function parseCookieHeader(cookieHeader) {
+  const cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader)
+    return cookies;
+  const pairs = cookieHeader.split(/;\s*/);
+  for (const pair of pairs) {
+    const [name, ...valueParts] = pair.split("=");
+    if (name) {
+      const value = valueParts.join("=");
+      cookies.set(name.trim(), decodeURIComponent(value || ""));
+    }
+  }
+  return cookies;
+}
+function serializeCookie(cookie) {
+  let header = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+  if (cookie.expires !== void 0 && cookie.expires !== null) {
+    const date = new Date(cookie.expires);
+    header += `; Expires=${date.toUTCString()}`;
+  }
+  if (cookie.domain) {
+    header += `; Domain=${cookie.domain}`;
+  }
+  if (cookie.path) {
+    header += `; Path=${cookie.path}`;
+  } else {
+    header += `; Path=/`;
+  }
+  if (cookie.sameSite) {
+    header += `; SameSite=${cookie.sameSite.charAt(0).toUpperCase() + cookie.sameSite.slice(1)}`;
+  } else {
+    header += `; SameSite=Strict`;
+  }
+  if (cookie.partitioned) {
+    header += `; Partitioned`;
+  }
+  header += `; Secure`;
+  return header;
+}
+function parseSetCookieHeader(setCookieHeader) {
+  const parts = setCookieHeader.split(/;\s*/);
+  const [nameValue, ...attributes] = parts;
+  const [name, ...valueParts] = nameValue.split("=");
+  const value = valueParts.join("=");
+  const cookie = {
+    name: decodeURIComponent(name.trim()),
+    value: decodeURIComponent(value || "")
+  };
+  for (const attr of attributes) {
+    const [key, ...attrValueParts] = attr.split("=");
+    const attrKey = key.trim().toLowerCase();
+    const attrValue = attrValueParts.join("=").trim();
+    switch (attrKey) {
+      case "expires":
+        cookie.expires = new Date(attrValue).getTime();
+        break;
+      case "max-age":
+        cookie.expires = Date.now() + parseInt(attrValue, 10) * 1e3;
+        break;
+      case "domain":
+        cookie.domain = attrValue;
+        break;
+      case "path":
+        cookie.path = attrValue;
+        break;
+      case "secure":
+        cookie.secure = true;
+        break;
+      case "samesite":
+        cookie.sameSite = attrValue.toLowerCase();
+        break;
+      case "partitioned":
+        cookie.partitioned = true;
+        break;
+    }
+  }
+  return cookie;
+}
+var RequestCookieStore = class extends EventTarget {
+  #cookies;
+  #changes;
+  // null = deleted
+  #request;
+  // Event handler for cookie changes (spec compliance)
+  // eslint-disable-next-line no-restricted-syntax
+  onchange = null;
+  constructor(request) {
+    super();
+    this.#cookies = /* @__PURE__ */ new Map();
+    this.#changes = /* @__PURE__ */ new Map();
+    this.#request = request || null;
+    if (request) {
+      const cookieHeader = request.headers.get("cookie");
+      if (cookieHeader) {
+        const parsed = parseCookieHeader(cookieHeader);
+        for (const [name, value] of parsed) {
+          this.#cookies.set(name, { name, value });
+        }
+      }
+    }
+  }
+  async get(nameOrOptions) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
+    if (!name) {
+      throw new TypeError("Cookie name is required");
+    }
+    if (this.#changes.has(name)) {
+      const change = this.#changes.get(name);
+      if (change === null || change === void 0)
+        return null;
+      return {
+        name: change.name,
+        value: change.value,
+        domain: change.domain ?? void 0,
+        path: change.path,
+        expires: change.expires ?? void 0,
+        sameSite: change.sameSite,
+        partitioned: change.partitioned
+      };
+    }
+    return this.#cookies.get(name) || null;
+  }
+  async getAll(nameOrOptions) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name;
+    const result = [];
+    const allNames = /* @__PURE__ */ new Set([
+      ...this.#cookies.keys(),
+      ...this.#changes.keys()
+    ]);
+    for (const cookieName of allNames) {
+      if (name && cookieName !== name)
+        continue;
+      if (this.#changes.has(cookieName) && this.#changes.get(cookieName) === null) {
+        continue;
+      }
+      const cookie = await this.get(cookieName);
+      if (cookie) {
+        result.push(cookie);
+      }
+    }
+    return result;
+  }
+  async set(nameOrOptions, value) {
+    let cookie;
+    if (typeof nameOrOptions === "string") {
+      if (value === void 0) {
+        throw new TypeError("Cookie value is required");
+      }
+      cookie = {
+        name: nameOrOptions,
+        value,
+        path: "/",
+        sameSite: "strict"
+      };
+    } else {
+      cookie = {
+        path: "/",
+        sameSite: "strict",
+        ...nameOrOptions
+      };
+    }
+    const size = cookie.name.length + cookie.value.length;
+    if (size > 4096) {
+      throw new TypeError(
+        `Cookie name+value too large: ${size} bytes (max 4096)`
+      );
+    }
+    this.#changes.set(cookie.name, cookie);
+  }
+  async delete(nameOrOptions) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
+    if (!name) {
+      throw new TypeError("Cookie name is required");
+    }
+    this.#changes.set(name, null);
+  }
+  /**
+   * Get Set-Cookie headers for all changes
+   * This should be called when constructing the Response
+   */
+  getSetCookieHeaders() {
+    const headers = [];
+    for (const [name, change] of this.#changes) {
+      if (change === null) {
+        headers.push(
+          serializeCookie({
+            name,
+            value: "",
+            expires: 0,
+            path: "/"
+          })
+        );
+      } else {
+        headers.push(serializeCookie(change));
+      }
+    }
+    return headers;
+  }
+  hasChanges() {
+    return this.#changes.size > 0;
+  }
+  clearChanges() {
+    this.#changes.clear();
+  }
+};
+var CustomLoggerStorage = class {
+  #factory;
+  constructor(factory) {
+    this.#factory = factory;
+  }
+  open(...categories) {
+    return this.#factory(...categories);
+  }
+};
+var SERVICE_WORKER_EVENTS = ["fetch", "install", "activate"];
+function isServiceWorkerEvent(type) {
+  return SERVICE_WORKER_EVENTS.includes(type);
+}
 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",
+  "directories",
+  "loggers",
+  "registration",
+  "clients",
+  "skipWaiting",
+  "addEventListener",
+  "removeEventListener",
+  "dispatchEvent",
+  "WorkerGlobalScope",
+  "DedicatedWorkerGlobalScope",
+  "cookieStore"
+];
 function promiseWithTimeout(promise, timeoutMs, errorMessage) {
   return Promise.race([
     promise,
@@ -114,9 +349,7 @@ var ShovelClient = class {
   }
   // Implementation
   postMessage(_message, _transferOrOptions) {
-    logger.warn(
-      "[ServiceWorker] Client.postMessage() not supported in server context"
-    );
+    self.loggers.open("platform").warn("Client.postMessage() not supported in server context");
   }
 };
 var ShovelWindowClient = class extends ShovelClient {
@@ -128,15 +361,11 @@ var ShovelWindowClient = class extends ShovelClient {
     this.visibilityState = options.visibilityState || "hidden";
   }
   async focus() {
-    logger.warn(
-      "[ServiceWorker] WindowClient.focus() not supported in server context"
-    );
+    self.loggers.open("platform").warn("WindowClient.focus() not supported in server context");
     return this;
   }
   async navigate(_url) {
-    logger.warn(
-      "[ServiceWorker] WindowClient.navigate() not supported in server context"
-    );
+    self.loggers.open("platform").warn("WindowClient.navigate() not supported in server context");
     return null;
   }
 };
@@ -150,9 +379,7 @@ var ShovelClients = class {
     return [];
   }
   async openWindow(_url) {
-    logger.warn(
-      "[ServiceWorker] Clients.openWindow() not supported in server context"
-    );
+    self.loggers.open("platform").warn("Clients.openWindow() not supported in server context");
     return null;
   }
 };
@@ -186,9 +413,7 @@ var ShovelServiceWorker = class extends EventTarget {
   }
   // Implementation
   postMessage(_message, _transferOrOptions) {
-    logger.warn(
-      "[ServiceWorker] ServiceWorker.postMessage() not implemented in server context"
-    );
+    self.loggers.open("platform").warn("ServiceWorker.postMessage() not implemented in server context");
   }
   // Internal method to update state and dispatch statechange event
   _setState(newState) {
@@ -220,9 +445,9 @@ var ShovelServiceWorkerRegistration = class extends EventTarget {
   cookies;
   pushManager;
   onupdatefound;
-  constructor(scope2 = "/", scriptURL = "/") {
+  constructor(scope = "/", scriptURL = "/") {
     super();
-    this.scope = scope2;
+    this.scope = scope;
     this.updateViaCache = "imports";
     this.navigationPreload = new ShovelNavigationPreloadManager();
     this._serviceWorker = new ShovelServiceWorker(scriptURL, "parsed");
@@ -245,9 +470,7 @@ var ShovelServiceWorkerRegistration = class extends EventTarget {
     return [];
   }
   async showNotification(_title, _options) {
-    logger.warn(
-      "[ServiceWorker] Notifications not supported in server context"
-    );
+    self.loggers.open("platform").warn("Notifications not supported in server context");
   }
   async sync() {
   }
@@ -346,7 +569,9 @@ var ShovelServiceWorkerRegistration = class extends EventTarget {
       const response = await event.getResponse();
       const promises = event.getPromises();
       if (promises.length > 0) {
-        Promise.allSettled(promises).catch(logger.error);
+        Promise.allSettled(promises).catch(
+          (err) => self.loggers.open("platform").error`waitUntil error: ${err}`
+        );
       }
       if (event.cookieStore.hasChanges()) {
         const setCookieHeaders = event.cookieStore.getSetCookieHeaders();
@@ -393,8 +618,8 @@ var ShovelServiceWorkerContainer = class extends EventTarget {
   /**
    * Get registration for a specific scope
    */
-  async getRegistration(scope2 = "/") {
-    return this.#registrations.get(scope2);
+  async getRegistration(scope = "/") {
+    return this.#registrations.get(scope);
   }
   /**
    * Get all registrations
@@ -407,26 +632,26 @@ var ShovelServiceWorkerContainer = class extends EventTarget {
    */
   async register(scriptURL, options) {
     const url = typeof scriptURL === "string" ? scriptURL : scriptURL.toString();
-    const scope2 = this.#normalizeScope(options?.scope || "/");
-    let registration2 = this.#registrations.get(scope2);
-    if (registration2) {
-      registration2._serviceWorker.scriptURL = url;
-      registration2._serviceWorker._setState("parsed");
+    const scope = this.#normalizeScope(options?.scope || "/");
+    let registration = this.#registrations.get(scope);
+    if (registration) {
+      registration._serviceWorker.scriptURL = url;
+      registration._serviceWorker._setState("parsed");
     } else {
-      registration2 = new ShovelServiceWorkerRegistration(scope2, url);
-      this.#registrations.set(scope2, registration2);
+      registration = new ShovelServiceWorkerRegistration(scope, url);
+      this.#registrations.set(scope, registration);
       this.dispatchEvent(new Event("updatefound"));
     }
-    return registration2;
+    return registration;
   }
   /**
    * Unregister a ServiceWorker registration
    */
-  async unregister(scope2) {
-    const registration2 = this.#registrations.get(scope2);
-    if (registration2) {
-      await registration2.unregister();
-      this.#registrations.delete(scope2);
+  async unregister(scope) {
+    const registration = this.#registrations.get(scope);
+    if (registration) {
+      await registration.unregister();
+      this.#registrations.delete(scope);
       return true;
     }
     return false;
@@ -439,9 +664,9 @@ var ShovelServiceWorkerContainer = class extends EventTarget {
     const pathname = url.pathname;
     const matchingScope = this.#findMatchingScope(pathname);
     if (matchingScope) {
-      const registration2 = this.#registrations.get(matchingScope);
-      if (registration2 && registration2.ready) {
-        return await registration2.handleRequest(request);
+      const registration = this.#registrations.get(matchingScope);
+      if (registration && registration.ready) {
+        return await registration.handleRequest(request);
       }
     }
     return null;
@@ -451,9 +676,9 @@ var ShovelServiceWorkerContainer = class extends EventTarget {
    */
   async installAll() {
     const installations = Array.from(this.#registrations.values()).map(
-      async (registration2) => {
-        await registration2.install();
-        await registration2.activate();
+      async (registration) => {
+        await registration.install();
+        await registration.activate();
       }
     );
     await promiseWithTimeout(
@@ -473,14 +698,14 @@ var ShovelServiceWorkerContainer = class extends EventTarget {
   /**
    * Normalize scope to ensure it starts and ends correctly
    */
-  #normalizeScope(scope2) {
-    if (!scope2.startsWith("/")) {
-      scope2 = "/" + scope2;
+  #normalizeScope(scope) {
+    if (!scope.startsWith("/")) {
+      scope = "/" + scope;
     }
-    if (scope2 !== "/" && !scope2.endsWith("/")) {
-      scope2 = scope2 + "/";
+    if (scope !== "/" && !scope.endsWith("/")) {
+      scope = scope + "/";
     }
-    return scope2;
+    return scope;
   }
   /**
    * Find the most specific scope that matches a pathname
@@ -488,9 +713,9 @@ var ShovelServiceWorkerContainer = class extends EventTarget {
   #findMatchingScope(pathname) {
     const scopes = Array.from(this.#registrations.keys());
     scopes.sort((a, b) => b.length - a.length);
-    for (const scope2 of scopes) {
-      if (pathname.startsWith(scope2 === "/" ? "/" : scope2)) {
-        return scope2;
+    for (const scope of scopes) {
+      if (pathname.startsWith(scope === "/" ? "/" : scope)) {
+        return scope;
       }
     }
     return null;
@@ -542,9 +767,7 @@ var Notification = class extends EventTarget {
     this.onshow = null;
   }
   close() {
-    logger.warn(
-      "[ServiceWorker] Notification.close() not supported in server context"
-    );
+    self.loggers.open("platform").warn("Notification.close() not supported in server context");
   }
   static async requestPermission() {
     return "denied";
@@ -609,7 +832,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;
@@ -618,12 +841,15 @@ var ShovelGlobalScope = class {
   registration;
   // Storage APIs
   caches;
-  buckets;
+  directories;
+  loggers;
   // Clients API
   // Our custom Clients implementation provides core functionality compatible with the Web API
   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
@@ -643,9 +869,7 @@ var ShovelGlobalScope = class {
   crypto;
   // WorkerGlobalScope methods (stubs for server context)
   importScripts(..._urls) {
-    logger.warn(
-      "[ServiceWorker] importScripts() not supported in server context"
-    );
+    self.loggers.open("platform").warn("importScripts() not supported in server context");
   }
   atob(data) {
     return globalThis.atob(data);
@@ -665,13 +889,28 @@ 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);
   }
   reportError(e) {
-    logger.error("[ServiceWorker] reportError:", e);
+    self.loggers.open("platform").error`reportError: ${e}`;
   }
   setInterval(handler, timeout, ...args) {
     return globalThis.setInterval(handler, timeout, ...args);
@@ -703,10 +942,16 @@ 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;
+    this.directories = options.directories;
+    this.loggers = options.loggers;
     this.#isDevelopment = options.isDevelopment ?? false;
     this.clients = this.#createClientsAPI();
     this.serviceWorker = null;
@@ -742,28 +987,48 @@ var ShovelGlobalScope = class {
    * Allows the ServiceWorker to activate immediately
    */
   async skipWaiting() {
-    logger.info("[ServiceWorker] skipWaiting() called");
+    self.loggers.open("platform").info("skipWaiting() called");
     if (!this.#isDevelopment) {
-      logger.info(
-        "[ServiceWorker] skipWaiting() - production graceful restart not implemented"
-      );
+      self.loggers.open("platform").info("skipWaiting() - production graceful restart not implemented");
     }
   }
   /**
-   * Event target delegation to registration
+   * Event target delegation - ServiceWorker events go to registration,
+   * other events (like "message" for worker threads) go to native handler
    */
   addEventListener(type, listener, options) {
-    if (listener) {
+    if (!listener)
+      return;
+    if (isServiceWorkerEvent(type)) {
       this.registration.addEventListener(type, listener, options);
+    } else {
+      const original = this.#originals.addEventListener;
+      if (original) {
+        original.call(globalThis, type, listener, options);
+      }
     }
   }
   removeEventListener(type, listener, options) {
-    if (listener) {
+    if (!listener)
+      return;
+    if (isServiceWorkerEvent(type)) {
       this.registration.removeEventListener(type, listener, options);
+    } else {
+      const original = this.#originals.removeEventListener;
+      if (original) {
+        original.call(globalThis, type, listener, options);
+      }
     }
   }
   dispatchEvent(event) {
-    return this.registration.dispatchEvent(event);
+    if (isServiceWorkerEvent(event.type)) {
+      return this.registration.dispatchEvent(event);
+    }
+    const original = this.#originals.dispatchEvent;
+    if (original) {
+      return original.call(globalThis, event);
+    }
+    return false;
   }
   /**
    * Create Clients API implementation
@@ -774,211 +1039,145 @@ 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;
-    }
-    if (this.buckets) {
-      globalThis.buckets = this.buckets;
-    }
-    globalThis.registration = this.registration;
-    globalThis.skipWaiting = this.skipWaiting.bind(this);
-    globalThis.clients = this.clients;
-  }
-};
-var logger = getLogger(["worker"]);
-async function initializeWorker() {
-  const messagePort = globalThis;
-  const sendMessage2 = (message, transfer) => {
-    if (transfer && transfer.length > 0) {
-      postMessage(message, transfer);
-    } else {
-      postMessage(message);
+    const g = globalThis;
+    g.WorkerGlobalScope = WorkerGlobalScope;
+    g.DedicatedWorkerGlobalScope = DedicatedWorkerGlobalScope;
+    if (typeof g.self === "undefined") {
+      g.self = globalThis;
     }
-  };
-  onmessage = function(event) {
-    void handleMessage(event.data);
-  };
-  return { messagePort, sendMessage: sendMessage2 };
-}
-var registration = null;
-var scope = null;
-var _workerSelf = null;
-var currentApp = null;
-var serviceWorkerReady = false;
-var loadedEntrypoint = null;
-var caches;
-var buckets;
-async function handleFetchEvent(request) {
-  if (!currentApp || !serviceWorkerReady) {
-    throw new Error("ServiceWorker not ready");
-  }
-  if (!registration) {
-    throw new Error("ServiceWorker runtime not initialized");
-  }
-  try {
-    const response = await registration.handleRequest(request);
-    return response;
-  } catch (error) {
-    logger.error("[Worker] ServiceWorker request failed", { error });
-    console.error("[Worker] ServiceWorker request failed:", error);
-    const response = new Response("ServiceWorker request failed", {
-      status: 500
+    g.addEventListener = this.addEventListener.bind(this);
+    g.removeEventListener = this.removeEventListener.bind(this);
+    g.dispatchEvent = this.dispatchEvent.bind(this);
+    g.caches = this.caches;
+    g.directories = this.directories;
+    g.loggers = this.loggers;
+    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
     });
-    return response;
   }
-}
-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();
-      if (!caches || !buckets) {
-        throw new Error("Runtime not initialized - missing caches or buckets");
+  /**
+   * 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;
       }
-      scope = new ShovelGlobalScope({
-        registration,
-        caches,
-        buckets
-      });
-      scope.install();
-      _workerSelf = scope;
-      currentApp = null;
-      serviceWorkerReady = false;
-    }
-    if (loadedEntrypoint === entrypoint) {
-      logger.info("[Worker] ServiceWorker already loaded for entrypoint", {
-        entrypoint
-      });
-      return;
     }
-    const appModule = await import(entrypoint);
-    loadedEntrypoint = entrypoint;
-    currentApp = appModule;
-    if (!registration) {
-      throw new Error("ServiceWorker runtime not initialized");
-    }
-    await registration.install();
-    await registration.activate();
-    serviceWorkerReady = true;
-    logger.info(
-      `[Worker] ServiceWorker loaded and activated from ${entrypoint}`
+  }
+};
+var SHOVEL_CATEGORIES = [
+  "cli",
+  "build",
+  "platform",
+  "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) {
+  const { provider, factory: preImportedFactory, ...sinkOptions } = config;
+  if (preImportedFactory) {
+    return preImportedFactory(sinkOptions);
+  }
+  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}"`
     );
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const errorStack = error instanceof Error ? error.stack : void 0;
-    logger.error("[Worker] Failed to load ServiceWorker", {
-      error: errorMessage,
-      stack: errorStack,
-      entrypoint
-    });
-    serviceWorkerReady = false;
-    throw error;
   }
+  return factory(sinkOptions);
 }
-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
-    });
-    logger.info(`[Worker-${workerId}] Creating cache storage`);
-    caches = new CustomCacheStorage(createCacheFactory({ config }));
-    logger.info(`[Worker-${workerId}] Creating bucket storage`);
-    buckets = new CustomBucketStorage(createBucketFactory({ baseDir, config }));
-    logger.info(`[Worker-${workerId}] Creating and installing scope`);
-    registration = new ShovelServiceWorkerRegistration();
-    scope = new ShovelGlobalScope({ registration, caches, buckets });
-    scope.install();
-    _workerSelf = scope;
-    logger.info(`[Worker-${workerId}] Runtime initialized successfully`);
-  } catch (error) {
-    logger.error(`[Worker-${workerId}] Failed to initialize runtime`, { error });
-    throw error;
+async function configureLogging(loggingConfig, options = {}) {
+  const level = loggingConfig.level || "info";
+  const defaultSinkConfigs = loggingConfig.sinks || [{ provider: "console" }];
+  const categories = loggingConfig.categories || {};
+  const reset = options.reset !== false;
+  const sinkByKey = /* @__PURE__ */ new Map();
+  for (const config of defaultSinkConfigs) {
+    const key = JSON.stringify(config);
+    if (!sinkByKey.has(key)) {
+      sinkByKey.set(key, { config, name: `sink_${sinkByKey.size}` });
+    }
   }
-}
-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";
+  for (const [_, categoryConfig] of Object.entries(categories)) {
+    if (categoryConfig.sinks) {
+      for (const config of categoryConfig.sinks) {
+        const key = JSON.stringify(config);
+        if (!sinkByKey.has(key)) {
+          sinkByKey.set(key, { config, name: `sink_${sinkByKey.size}` });
+        }
       }
-      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);
+    }
   }
-}
-if (typeof onmessage !== "undefined") {
-  initializeWorker().then(({ messagePort: _messagePort, sendMessage: send }) => {
-    sendMessage = send;
-    sendMessage({ type: "worker-ready" });
-  }).catch((error) => {
-    logger.error("[Worker] Failed to initialize:", error);
+  const sinks = {};
+  for (const { config, name } of sinkByKey.values()) {
+    sinks[name] = await createSink(config);
+  }
+  const getSinkNames = (configs) => {
+    return configs.map((config) => sinkByKey.get(JSON.stringify(config))?.name ?? "").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
   });
 }
 export {
   ActivateEvent,
+  CustomLoggerStorage,
   DedicatedWorkerGlobalScope,
   ExtendableEvent,
   ExtendableMessageEvent,
@@ -987,9 +1186,10 @@ export {
   Notification,
   NotificationEvent,
   PushEvent,
+  RequestCookieStore,
+  ServiceWorkerGlobals,
   ShovelClient,
   ShovelClients,
-  ShovelGlobalScope,
   ShovelNavigationPreloadManager,
   ShovelPushMessageData,
   ShovelServiceWorker,
@@ -997,5 +1197,9 @@ export {
   ShovelServiceWorkerRegistration,
   ShovelWindowClient,
   SyncEvent,
-  WorkerGlobalScope
+  WorkerGlobalScope,
+  configureLogging,
+  parseCookieHeader,
+  parseSetCookieHeader,
+  serializeCookie
 };