@b9g/platform 0.1.11 → 0.1.13

package/src/runtime.js

@@ -1,14 +1,341 @@
 /// <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 { getLogger, getConsoleSink } from "@logtape/logtape";
+import { CustomDirectoryStorage } 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 { handleCacheResponse, PostMessageCache } from "@b9g/cache/postmessage";
+import {
+  configure
+} from "@logtape/logtape";
+import { Database } from "@b9g/zen";
+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;
+  }
+  get(categories) {
+    return this.#factory(categories);
+  }
+};
+var CustomDatabaseStorage = class {
+  #factory;
+  #databases;
+  #closers;
+  #pending;
+  constructor(factory) {
+    this.#factory = factory;
+    this.#databases = /* @__PURE__ */ new Map();
+    this.#closers = /* @__PURE__ */ new Map();
+    this.#pending = /* @__PURE__ */ new Map();
+  }
+  async open(name, version, onUpgrade) {
+    const existing = this.#databases.get(name);
+    if (existing) {
+      return existing;
+    }
+    const pending = this.#pending.get(name);
+    if (pending) {
+      return pending;
+    }
+    const promise = (async () => {
+      const { db, close } = await this.#factory(name);
+      if (onUpgrade) {
+        db.addEventListener("upgradeneeded", (e) => {
+          const event = e;
+          onUpgrade({
+            db,
+            oldVersion: event.oldVersion,
+            newVersion: event.newVersion,
+            waitUntil: (p) => event.waitUntil(p)
+          });
+        });
+      }
+      try {
+        await db.open(version);
+      } catch (err) {
+        await close();
+        throw err;
+      }
+      this.#databases.set(name, db);
+      this.#closers.set(name, close);
+      return db;
+    })().finally(() => {
+      this.#pending.delete(name);
+    });
+    this.#pending.set(name, promise);
+    return promise;
+  }
+  get(name) {
+    const db = this.#databases.get(name);
+    if (!db) {
+      throw new Error(
+        `Database "${name}" has not been opened. Call self.databases.open("${name}", version) in your activate handler first.`
+      );
+    }
+    return db;
+  }
+  async close(name) {
+    const pending = this.#pending.get(name);
+    if (pending) {
+      try {
+        await pending;
+      } catch (_err) {
+        return;
+      }
+    }
+    const closer = this.#closers.get(name);
+    if (closer) {
+      await closer();
+      this.#databases.delete(name);
+      this.#closers.delete(name);
+    }
+  }
+  async closeAll() {
+    if (this.#pending.size > 0) {
+      await Promise.allSettled(this.#pending.values());
+    }
+    const promises = Array.from(this.#databases.keys()).map(
+      (name) => this.close(name)
+    );
+    await Promise.allSettled(promises);
+  }
+};
+function createDatabaseFactory(configs) {
+  return async (name) => {
+    const config = configs[name];
+    if (!config) {
+      throw new Error(
+        `Database "${name}" is not configured. Available databases: ${Object.keys(configs).join(", ") || "(none)"}`
+      );
+    }
+    const { impl, url, ...driverOptions } = config;
+    if (!impl) {
+      throw new Error(
+        `Database "${name}" has no impl. Ensure the database module is configured in shovel.json.`
+      );
+    }
+    if (!url) {
+      throw new Error(
+        `Database "${name}" has no url. Ensure the database URL is configured.`
+      );
+    }
+    const driver = new impl(url, driverOptions);
+    const db = new Database(driver);
+    return {
+      db,
+      close: async () => {
+        await driver.close();
+      }
+    };
+  };
+}
+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;
 }
@@ -19,7 +346,9 @@ var PATCHED_KEYS = [
   "self",
   "fetch",
   "caches",
-  "buckets",
+  "directories",
+  "databases",
+  "loggers",
   "registration",
   "clients",
   "skipWaiting",
@@ -38,9 +367,9 @@ function promiseWithTimeout(promise, timeoutMs, errorMessage) {
     )
   ]);
 }
-var kEndDispatchPhase = Symbol.for("shovel.endDispatchPhase");
-var kCanExtend = Symbol.for("shovel.canExtend");
-var ExtendableEvent = class extends Event {
+var kEndDispatchPhase = /* @__PURE__ */ Symbol.for("shovel.endDispatchPhase");
+var kCanExtend = /* @__PURE__ */ Symbol.for("shovel.canExtend");
+var ShovelExtendableEvent = class extends Event {
   #promises;
   #dispatchPhase;
   #pendingCount;
@@ -77,17 +406,33 @@ var ExtendableEvent = class extends Event {
     return this.#dispatchPhase || this.#pendingCount > 0;
   }
 };
-var FetchEvent = class extends ExtendableEvent {
+var ShovelFetchEvent = class extends ShovelExtendableEvent {
   request;
   cookieStore;
+  clientId;
+  handled;
+  preloadResponse;
+  resultingClientId;
   #responsePromise;
   #responded;
-  constructor(request, eventInitDict) {
-    super("fetch", eventInitDict);
+  #platformWaitUntil;
+  constructor(request, options) {
+    super("fetch", options);
     this.request = request;
     this.cookieStore = new RequestCookieStore(request);
+    this.clientId = "";
+    this.handled = Promise.resolve(void 0);
+    this.preloadResponse = Promise.resolve(void 0);
+    this.resultingClientId = "";
     this.#responsePromise = null;
     this.#responded = false;
+    this.#platformWaitUntil = options?.platformWaitUntil;
+  }
+  waitUntil(promise) {
+    if (this.#platformWaitUntil) {
+      this.#platformWaitUntil(promise);
+    }
+    super.waitUntil(promise);
   }
   respondWith(response) {
     if (this.#responded) {
@@ -109,13 +454,17 @@ var FetchEvent = class extends ExtendableEvent {
   hasResponded() {
     return this.#responded;
   }
+  /** The URL of the request (convenience property) */
+  get url() {
+    return this.request.url;
+  }
 };
-var InstallEvent = class extends ExtendableEvent {
+var ShovelInstallEvent = class extends ShovelExtendableEvent {
   constructor(eventInitDict) {
     super("install", eventInitDict);
   }
 };
-var ActivateEvent = class extends ExtendableEvent {
+var ShovelActivateEvent = class extends ShovelExtendableEvent {
   constructor(eventInitDict) {
     super("activate", eventInitDict);
   }
@@ -133,9 +482,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 {
@@ -147,15 +494,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;
   }
 };
@@ -169,13 +512,11 @@ 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;
   }
 };
-var ExtendableMessageEvent = class extends ExtendableEvent {
+var ExtendableMessageEvent = class extends ShovelExtendableEvent {
   data;
   origin;
   lastEventId;
@@ -205,9 +546,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) {
@@ -239,9 +578,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");
@@ -264,9 +603,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() {
   }
@@ -281,11 +618,10 @@ var ShovelServiceWorkerRegistration = class extends EventTarget {
    * Install the ServiceWorker (Shovel extension)
    */
   async install() {
-    if (this._serviceWorker.state !== "parsed")
-      return;
+    if (this._serviceWorker.state !== "parsed") return;
     this._serviceWorker._setState("installing");
     return new Promise((resolve, reject) => {
-      const event = new InstallEvent();
+      const event = new ShovelInstallEvent();
       process.nextTick(() => {
         try {
           this.dispatchEvent(event);
@@ -320,7 +656,7 @@ var ShovelServiceWorkerRegistration = class extends EventTarget {
     }
     this._serviceWorker._setState("activating");
     return new Promise((resolve, reject) => {
-      const event = new ActivateEvent();
+      const event = new ShovelActivateEvent();
       process.nextTick(() => {
         try {
           this.dispatchEvent(event);
@@ -348,12 +684,16 @@ var ShovelServiceWorkerRegistration = class extends EventTarget {
   }
   /**
    * Handle a fetch request (Shovel extension)
+   *
+   * Platforms create a ShovelFetchEvent (or subclass) with platform-specific
+   * properties and hooks, then pass it to this method for dispatching.
+   *
+   * @param event - The fetch event to handle (created by platform adapter)
    */
-  async handleRequest(request) {
+  async handleRequest(event) {
     if (this._serviceWorker.state !== "activated") {
       throw new Error("ServiceWorker not activated");
     }
-    const event = new FetchEvent(request);
     return cookieStoreStorage.run(event.cookieStore, async () => {
       this.dispatchEvent(event);
       event[kEndDispatchPhase]();
@@ -363,10 +703,6 @@ var ShovelServiceWorkerRegistration = class extends EventTarget {
         );
       }
       const response = await event.getResponse();
-      const promises = event.getPromises();
-      if (promises.length > 0) {
-        Promise.allSettled(promises).catch(logger.error);
-      }
       if (event.cookieStore.hasChanges()) {
         const setCookieHeaders = event.cookieStore.getSetCookieHeaders();
         const headers = new Headers(response.headers);
@@ -412,8 +748,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
@@ -426,26 +762,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;
@@ -458,9 +794,10 @@ 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) {
+        const event = new ShovelFetchEvent(request);
+        return await registration.handleRequest(event);
       }
     }
     return null;
@@ -470,9 +807,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(
@@ -492,14 +829,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
@@ -507,9 +844,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;
@@ -561,9 +898,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";
@@ -571,7 +906,7 @@ var Notification = class extends EventTarget {
   // Events: click, close, error, show
 };
 Notification.permission = "denied";
-var NotificationEvent = class extends ExtendableEvent {
+var NotificationEvent = class extends ShovelExtendableEvent {
   action;
   notification;
   reply;
@@ -582,7 +917,7 @@ var NotificationEvent = class extends ExtendableEvent {
     this.reply = eventInitDict.reply ?? null;
   }
 };
-var PushEvent = class extends ExtendableEvent {
+var PushEvent = class extends ShovelExtendableEvent {
   data;
   constructor(type, eventInitDict) {
     super(type, eventInitDict);
@@ -615,7 +950,7 @@ var ShovelPushMessageData = class {
     return new TextDecoder().decode(this._data);
   }
 };
-var SyncEvent = class extends ExtendableEvent {
+var SyncEvent = class extends ShovelExtendableEvent {
   tag;
   lastChance;
   constructor(type, eventInitDict) {
@@ -637,7 +972,9 @@ var ServiceWorkerGlobals = class {
   registration;
   // Storage APIs
   caches;
-  buckets;
+  directories;
+  databases;
+  loggers;
   // Clients API
   // Our custom Clients implementation provides core functionality compatible with the Web API
   clients;
@@ -664,9 +1001,7 @@ var ServiceWorkerGlobals = 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);
@@ -700,14 +1035,15 @@ var ServiceWorkerGlobals = class {
     }
     const request = new Request(new URL(urlString, "http://localhost"), init);
     return fetchDepthStorage.run(currentDepth + 1, () => {
-      return this.registration.handleRequest(request);
+      const event = new ShovelFetchEvent(request);
+      return this.registration.handleRequest(event);
     });
   }
   queueMicrotask(callback) {
     globalThis.queueMicrotask(callback);
   }
   reportError(e) {
-    logger.error("[ServiceWorker] reportError:", e);
+    getLogger(["shovel", "platform"]).error`reportError: ${e}`;
   }
   setInterval(handler, timeout, ...args) {
     return globalThis.setInterval(handler, timeout, ...args);
@@ -747,7 +1083,9 @@ var ServiceWorkerGlobals = class {
     this.self = globalThis;
     this.registration = options.registration;
     this.caches = options.caches;
-    this.buckets = options.buckets;
+    this.directories = options.directories;
+    this.databases = options.databases;
+    this.loggers = options.loggers;
     this.#isDevelopment = options.isDevelopment ?? false;
     this.clients = this.#createClientsAPI();
     this.serviceWorker = null;
@@ -783,28 +1121,48 @@ var ServiceWorkerGlobals = class {
    * Allows the ServiceWorker to activate immediately
    */
   async skipWaiting() {
-    logger.info("[ServiceWorker] skipWaiting() called");
+    getLogger(["shovel", "platform"]).info("skipWaiting() called");
     if (!this.#isDevelopment) {
-      logger.info(
-        "[ServiceWorker] skipWaiting() - production graceful restart not implemented"
+      getLogger(["shovel", "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
@@ -828,7 +1186,11 @@ var ServiceWorkerGlobals = class {
     g.removeEventListener = this.removeEventListener.bind(this);
     g.dispatchEvent = this.dispatchEvent.bind(this);
     g.caches = this.caches;
-    g.buckets = this.buckets;
+    g.directories = this.directories;
+    if (this.databases) {
+      g.databases = this.databases;
+    }
+    g.loggers = this.loggers;
     g.registration = this.registration;
     g.skipWaiting = this.skipWaiting.bind(this);
     g.clients = this.clients;
@@ -854,150 +1216,112 @@ var ServiceWorkerGlobals = class {
     }
   }
 };
-var logger = getLogger(["worker"]);
-async function initializeWorker() {
-  const messagePort = globalThis;
-  const sendMessage2 = (message, transfer) => {
-    if (transfer && transfer.length > 0) {
-      postMessage(message, transfer);
+function isClass(fn) {
+  return typeof fn === "function" && fn.prototype !== void 0;
+}
+function createDirectoryFactory(configs) {
+  return async (name) => {
+    const config = configs[name];
+    if (!config) {
+      throw new Error(
+        `Directory "${name}" is not configured. Available directories: ${Object.keys(configs).join(", ") || "(none)"}`
+      );
+    }
+    const { impl, ...dirOptions } = config;
+    if (!impl) {
+      throw new Error(
+        `Directory "${name}" has no impl. Ensure the directory module is configured.`
+      );
+    }
+    if (isClass(impl)) {
+      return new impl(name, dirOptions);
     } else {
-      postMessage(message);
+      return impl(name, dirOptions);
     }
   };
-  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}", { error });
-    console.error("[Worker] ServiceWorker request failed:", error);
-    const response = new Response("ServiceWorker request failed", {
-      status: 500
-    });
-    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}`
+function createCacheFactory(options) {
+  const { configs, usePostMessage = false } = options;
+  return async (name) => {
+    if (usePostMessage) {
+      return new PostMessageCache(name);
+    }
+    const config = configs[name];
+    if (!config) {
+      throw new Error(
+        `Cache "${name}" is not configured. Available caches: ${Object.keys(configs).join(", ") || "(none)"}`
       );
-      logger.info("[Worker] Creating completely fresh ServiceWorker context");
-      registration = new ShovelServiceWorkerRegistration();
-      if (!caches || !buckets) {
-        throw new Error("Runtime not initialized - missing caches or buckets");
-      }
-      scope = new ServiceWorkerGlobals({
-        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 { impl, ...cacheOptions } = config;
+    if (!impl) {
+      throw new Error(
+        `Cache "${name}" has no impl. Ensure the cache module is configured.`
+      );
     }
-    const appModule = await import(entrypoint);
-    loadedEntrypoint = entrypoint;
-    currentApp = appModule;
-    if (!registration) {
-      throw new Error("ServiceWorker runtime not initialized");
+    if (isClass(impl)) {
+      return new impl(name, cacheOptions);
+    } else {
+      return impl(name, cacheOptions);
     }
-    await registration.install();
-    await registration.activate();
-    serviceWorkerReady = true;
-    logger.info(
-      `[Worker] ServiceWorker loaded and activated from ${entrypoint}`
-    );
-  } 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;
-  }
+  };
 }
-var workerId = Math.random().toString(36).substring(2, 8);
-var sendMessage;
-async function initializeRuntime(config, baseDir) {
-  try {
-    if (config?.logging) {
-      await configureLogging(config.logging);
+async function initWorkerRuntime(options) {
+  const { config } = options;
+  const runtimeLogger = getLogger(["shovel", "platform"]);
+  if (config?.logging) {
+    await configureLogging(config.logging);
+  }
+  runtimeLogger.debug("Initializing worker runtime");
+  const caches = new CustomCacheStorage(
+    createCacheFactory({
+      configs: config?.caches ?? {},
+      usePostMessage: true
+    })
+  );
+  const directories = new CustomDirectoryStorage(
+    createDirectoryFactory(config?.directories ?? {})
+  );
+  let databases;
+  if (config?.databases && Object.keys(config.databases).length > 0) {
+    const factory = createDatabaseFactory(config.databases);
+    databases = new CustomDatabaseStorage(factory);
+  }
+  const loggers = new CustomLoggerStorage(
+    (categories) => getLogger(categories)
+  );
+  const registration = new ShovelServiceWorkerRegistration();
+  const scope = new ServiceWorkerGlobals({
+    registration,
+    caches,
+    directories,
+    databases,
+    loggers
+  });
+  scope.install();
+  runtimeLogger.debug("Worker runtime initialized");
+  return { registration, scope, caches, directories, databases, loggers };
+}
+function startWorkerMessageLoop(options) {
+  const registration = options instanceof ShovelServiceWorkerRegistration ? options : options.registration;
+  const databases = options instanceof ShovelServiceWorkerRegistration ? void 0 : options.databases;
+  const messageLogger = getLogger(["shovel", "platform"]);
+  const workerId = Math.random().toString(36).substring(2, 8);
+  function sendMessage(message, transfer) {
+    if (transfer && transfer.length > 0) {
+      postMessage(message, transfer);
+    } else {
+      postMessage(message);
     }
-    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 ServiceWorkerGlobals({ 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 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
+  async function handleFetchRequest(message) {
+    try {
+      const request = new Request(message.request.url, {
+        method: message.request.method,
+        headers: message.request.headers,
+        body: message.request.body
       });
-      const response = await handleFetchEvent(request);
+      const event = new ShovelFetchEvent(request);
+      const response = await registration.handleRequest(event);
       const body = await response.arrayBuffer();
       const headers = Object.fromEntries(response.headers.entries());
       if (!headers["Content-Type"] && !headers["content-type"]) {
@@ -1011,41 +1335,151 @@ async function handleMessage(message) {
           headers,
           body
         },
-        requestID: reqMsg.requestID
+        requestID: message.requestID
       };
       sendMessage(responseMsg, [body]);
+    } catch (error) {
+      messageLogger.error(`[Worker-${workerId}] Request failed: {error}`, {
+        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);
     }
-  } 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);
   }
+  function handleMessage(event) {
+    const message = event.data;
+    if (message?.type === "cache:response" || message?.type === "cache:error") {
+      messageLogger.debug(`[Worker-${workerId}] Forwarding cache message`, {
+        type: message.type,
+        requestID: message.requestID
+      });
+      handleCacheResponse(message);
+      return;
+    }
+    if (message?.type === "request") {
+      handleFetchRequest(message).catch((error) => {
+        messageLogger.error(`[Worker-${workerId}] Unhandled error: {error}`, {
+          error
+        });
+      });
+      return;
+    }
+    if (message?.type === "shutdown") {
+      messageLogger.debug(`[Worker-${workerId}] Received shutdown signal`);
+      (async () => {
+        try {
+          if (databases) {
+            await databases.closeAll();
+            messageLogger.debug(`[Worker-${workerId}] Databases closed`);
+          }
+          sendMessage({ type: "shutdown-complete" });
+          messageLogger.debug(`[Worker-${workerId}] Shutdown complete`);
+        } catch (error) {
+          messageLogger.error(`[Worker-${workerId}] Shutdown error: {error}`, {
+            error
+          });
+          sendMessage({ type: "shutdown-complete" });
+        }
+      })();
+      return;
+    }
+    if (message?.type) {
+      messageLogger.debug(`[Worker-${workerId}] Unknown message type`, {
+        type: message.type
+      });
+    }
+  }
+  self.addEventListener("message", handleMessage);
+  sendMessage({ type: "ready" });
+  messageLogger.debug(`[Worker-${workerId}] Message loop started`);
 }
-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);
+var SHOVEL_DEFAULT_LOGGERS = [
+  { category: ["shovel"], level: "info", sinks: ["console"] },
+  { category: ["logtape", "meta"], level: "warning", sinks: ["console"] }
+];
+async function createSink(config) {
+  const {
+    impl,
+    path,
+    // Extract path for file-based sinks
+    ...sinkOptions
+  } = config;
+  if (!impl) {
+    throw new Error(
+      `Sink has no impl. Ensure the sink module is configured in shovel.json.`
+    );
+  }
+  if (path !== void 0) {
+    return impl(path, sinkOptions);
+  } else if (Object.keys(sinkOptions).length > 0) {
+    return impl(sinkOptions);
+  } else {
+    return impl();
+  }
+}
+function normalizeCategory(category) {
+  return typeof category === "string" ? [category] : category;
+}
+async function configureLogging(loggingConfig) {
+  const userSinks = loggingConfig.sinks || {};
+  const userLoggers = loggingConfig.loggers || [];
+  const sinks = {
+    console: getConsoleSink()
+  };
+  for (const [name, config] of Object.entries(userSinks)) {
+    sinks[name] = await createSink(config);
+  }
+  const userCategoryKeys = new Set(
+    userLoggers.map((l) => JSON.stringify(normalizeCategory(l.category)))
+  );
+  const mergedLoggers = [
+    // Shovel defaults (unless overridden by user)
+    ...SHOVEL_DEFAULT_LOGGERS.filter(
+      (l) => !userCategoryKeys.has(JSON.stringify(normalizeCategory(l.category)))
+    ),
+    // User loggers
+    ...userLoggers
+  ];
+  const loggers = mergedLoggers.map((loggerConfig) => {
+    const result = {
+      category: normalizeCategory(loggerConfig.category)
+    };
+    if (loggerConfig.level) {
+      result.lowestLevel = loggerConfig.level;
+    }
+    result.sinks = loggerConfig.sinks ?? ["console"];
+    if (loggerConfig.parentSinks) {
+      result.parentSinks = loggerConfig.parentSinks;
+    }
+    return result;
+  });
+  await configure({
+    reset: true,
+    sinks,
+    loggers
   });
 }
 export {
-  ActivateEvent,
+  CustomDatabaseStorage,
+  CustomLoggerStorage,
   DedicatedWorkerGlobalScope,
-  ExtendableEvent,
   ExtendableMessageEvent,
-  FetchEvent,
-  InstallEvent,
   Notification,
   NotificationEvent,
   PushEvent,
+  RequestCookieStore,
   ServiceWorkerGlobals,
+  ShovelActivateEvent,
   ShovelClient,
   ShovelClients,
+  ShovelExtendableEvent,
+  ShovelFetchEvent,
+  ShovelInstallEvent,
   ShovelNavigationPreloadManager,
   ShovelPushMessageData,
   ShovelServiceWorker,
@@ -1053,5 +1487,14 @@ export {
   ShovelServiceWorkerRegistration,
   ShovelWindowClient,
   SyncEvent,
-  WorkerGlobalScope
+  WorkerGlobalScope,
+  configureLogging,
+  createCacheFactory,
+  createDatabaseFactory,
+  createDirectoryFactory,
+  initWorkerRuntime,
+  parseCookieHeader,
+  parseSetCookieHeader,
+  serializeCookie,
+  startWorkerMessageLoop
 };