@b9g/platform 0.1.12 → 0.1.13

package/src/runtime.js

@@ -1,15 +1,17 @@
 /// <reference types="./runtime.d.ts" />
-import "../chunk-P57PW2II.js";
-
 // src/runtime.ts
 import { AsyncContext } from "@b9g/async-context";
+import { getLogger, getConsoleSink } from "@logtape/logtape";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { CustomCacheStorage } from "@b9g/cache";
+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;
+  if (!cookieHeader) return cookies;
   const pairs = cookieHeader.split(/;\s*/);
   for (const pair of pairs) {
     const [name, ...valueParts] = pair.split("=");
@@ -114,8 +116,7 @@ var RequestCookieStore = class extends EventTarget {
     }
     if (this.#changes.has(name)) {
       const change = this.#changes.get(name);
-      if (change === null || change === void 0)
-        return null;
+      if (change === null || change === void 0) return null;
       return {
         name: change.name,
         value: change.value,
@@ -136,8 +137,7 @@ var RequestCookieStore = class extends EventTarget {
       ...this.#changes.keys()
     ]);
     for (const cookieName of allNames) {
-      if (name && cookieName !== name)
-        continue;
+      if (name && cookieName !== name) continue;
       if (this.#changes.has(cookieName) && this.#changes.get(cookieName) === null) {
         continue;
       }
@@ -216,10 +216,122 @@ var CustomLoggerStorage = class {
   constructor(factory) {
     this.#factory = factory;
   }
-  open(...categories) {
-    return this.#factory(...categories);
+  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);
@@ -235,6 +347,7 @@ var PATCHED_KEYS = [
   "fetch",
   "caches",
   "directories",
+  "databases",
   "loggers",
   "registration",
   "clients",
@@ -254,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;
@@ -293,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) {
@@ -325,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);
   }
@@ -383,7 +516,7 @@ var ShovelClients = class {
     return null;
   }
 };
-var ExtendableMessageEvent = class extends ExtendableEvent {
+var ExtendableMessageEvent = class extends ShovelExtendableEvent {
   data;
   origin;
   lastEventId;
@@ -485,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);
@@ -524,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);
@@ -552,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]();
@@ -567,12 +703,6 @@ var ShovelServiceWorkerRegistration = class extends EventTarget {
         );
       }
       const response = await event.getResponse();
-      const promises = event.getPromises();
-      if (promises.length > 0) {
-        Promise.allSettled(promises).catch(
-          (err) => self.loggers.open("platform").error`waitUntil error: ${err}`
-        );
-      }
       if (event.cookieStore.hasChanges()) {
         const setCookieHeaders = event.cookieStore.getSetCookieHeaders();
         const headers = new Headers(response.headers);
@@ -666,7 +796,8 @@ var ShovelServiceWorkerContainer = class extends EventTarget {
     if (matchingScope) {
       const registration = this.#registrations.get(matchingScope);
       if (registration && registration.ready) {
-        return await registration.handleRequest(request);
+        const event = new ShovelFetchEvent(request);
+        return await registration.handleRequest(event);
       }
     }
     return null;
@@ -775,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;
@@ -786,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);
@@ -819,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) {
@@ -842,6 +973,7 @@ var ServiceWorkerGlobals = class {
   // Storage APIs
   caches;
   directories;
+  databases;
   loggers;
   // Clients API
   // Our custom Clients implementation provides core functionality compatible with the Web API
@@ -903,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) {
-    self.loggers.open("platform").error`reportError: ${e}`;
+    getLogger(["shovel", "platform"]).error`reportError: ${e}`;
   }
   setInterval(handler, timeout, ...args) {
     return globalThis.setInterval(handler, timeout, ...args);
@@ -951,6 +1084,7 @@ var ServiceWorkerGlobals = class {
     this.registration = options.registration;
     this.caches = options.caches;
     this.directories = options.directories;
+    this.databases = options.databases;
     this.loggers = options.loggers;
     this.#isDevelopment = options.isDevelopment ?? false;
     this.clients = this.#createClientsAPI();
@@ -987,9 +1121,11 @@ var ServiceWorkerGlobals = class {
    * Allows the ServiceWorker to activate immediately
    */
   async skipWaiting() {
-    self.loggers.open("platform").info("skipWaiting() called");
+    getLogger(["shovel", "platform"]).info("skipWaiting() called");
     if (!this.#isDevelopment) {
-      self.loggers.open("platform").info("skipWaiting() - production graceful restart not implemented");
+      getLogger(["shovel", "platform"]).info(
+        "skipWaiting() - production graceful restart not implemented"
+      );
     }
   }
   /**
@@ -997,8 +1133,7 @@ var ServiceWorkerGlobals = class {
    * other events (like "message" for worker threads) go to native handler
    */
   addEventListener(type, listener, options) {
-    if (!listener)
-      return;
+    if (!listener) return;
     if (isServiceWorkerEvent(type)) {
       this.registration.addEventListener(type, listener, options);
     } else {
@@ -1009,8 +1144,7 @@ var ServiceWorkerGlobals = class {
     }
   }
   removeEventListener(type, listener, options) {
-    if (!listener)
-      return;
+    if (!listener) return;
     if (isServiceWorkerEvent(type)) {
       this.registration.removeEventListener(type, listener, options);
     } else {
@@ -1053,6 +1187,9 @@ var ServiceWorkerGlobals = class {
     g.dispatchEvent = this.dispatchEvent.bind(this);
     g.caches = this.caches;
     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);
@@ -1079,117 +1216,270 @@ var ServiceWorkerGlobals = class {
     }
   }
 };
-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}"`
-    );
-  }
-  return factory(sinkOptions);
+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 {
+      return impl(name, dirOptions);
+    }
+  };
+}
+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)"}`
+      );
+    }
+    const { impl, ...cacheOptions } = config;
+    if (!impl) {
+      throw new Error(
+        `Cache "${name}" has no impl. Ensure the cache module is configured.`
+      );
+    }
+    if (isClass(impl)) {
+      return new impl(name, cacheOptions);
+    } else {
+      return impl(name, cacheOptions);
+    }
+  };
+}
+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 };
 }
-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}` });
+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);
     }
   }
-  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}` });
-        }
+  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 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"]) {
+        headers["Content-Type"] = "text/plain; charset=utf-8";
       }
+      const responseMsg = {
+        type: "response",
+        response: {
+          status: response.status,
+          statusText: response.statusText,
+          headers,
+          body
+        },
+        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);
     }
   }
-  const sinks = {};
-  for (const { config, name } of sinkByKey.values()) {
-    sinks[name] = await createSink(config);
+  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`);
+}
+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.`
+    );
   }
-  const getSinkNames = (configs) => {
-    return configs.map((config) => sinkByKey.get(JSON.stringify(config))?.name ?? "").filter(Boolean);
+  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()
   };
-  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
+  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)
     };
-  });
-  loggers.push({
-    category: ["logtape", "meta"],
-    level: "warning",
-    sinks: []
+    if (loggerConfig.level) {
+      result.lowestLevel = loggerConfig.level;
+    }
+    result.sinks = loggerConfig.sinks ?? ["console"];
+    if (loggerConfig.parentSinks) {
+      result.parentSinks = loggerConfig.parentSinks;
+    }
+    return result;
   });
   await configure({
-    reset,
+    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,
@@ -1199,7 +1489,12 @@ export {
   SyncEvent,
   WorkerGlobalScope,
   configureLogging,
+  createCacheFactory,
+  createDatabaseFactory,
+  createDirectoryFactory,
+  initWorkerRuntime,
   parseCookieHeader,
   parseSetCookieHeader,
-  serializeCookie
+  serializeCookie,
+  startWorkerMessageLoop
 };