@b9g/platform 0.1.4 → 0.1.5

package/src/runtime.js

@@ -0,0 +1,997 @@
+/// <reference types="./runtime.d.ts" />
+// 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";
+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();
+function promiseWithTimeout(promise, timeoutMs, errorMessage) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs)
+    )
+  ]);
+}
+var kEndDispatchPhase = Symbol.for("shovel.endDispatchPhase");
+var kCanExtend = Symbol.for("shovel.canExtend");
+var ExtendableEvent = class extends Event {
+  #promises;
+  #dispatchPhase;
+  #pendingCount;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.#promises = [];
+    this.#dispatchPhase = true;
+    this.#pendingCount = 0;
+  }
+  waitUntil(promise) {
+    if (!this.#dispatchPhase && this.#pendingCount === 0) {
+      throw new DOMException(
+        "waitUntil() must be called synchronously during event dispatch, or while there are pending promises from respondWith()/waitUntil()",
+        "InvalidStateError"
+      );
+    }
+    this.#pendingCount++;
+    const trackedPromise = promise.finally(() => {
+      this.#pendingCount--;
+    });
+    trackedPromise.catch(() => {
+    });
+    this.#promises.push(trackedPromise);
+  }
+  getPromises() {
+    return [...this.#promises];
+  }
+  /** @internal Called after synchronous dispatch completes */
+  [kEndDispatchPhase]() {
+    this.#dispatchPhase = false;
+  }
+  /** @internal Check if extensions are still allowed */
+  [kCanExtend]() {
+    return this.#dispatchPhase || this.#pendingCount > 0;
+  }
+};
+var FetchEvent = class extends ExtendableEvent {
+  request;
+  cookieStore;
+  #responsePromise;
+  #responded;
+  constructor(request, eventInitDict) {
+    super("fetch", eventInitDict);
+    this.request = request;
+    this.cookieStore = new RequestCookieStore(request);
+    this.#responsePromise = null;
+    this.#responded = false;
+  }
+  respondWith(response) {
+    if (this.#responded) {
+      throw new Error("respondWith() already called");
+    }
+    if (!this[kCanExtend]()) {
+      throw new DOMException(
+        "respondWith() must be called synchronously during event dispatch",
+        "InvalidStateError"
+      );
+    }
+    this.#responded = true;
+    this.#responsePromise = Promise.resolve(response);
+    this.waitUntil(this.#responsePromise);
+  }
+  getResponse() {
+    return this.#responsePromise;
+  }
+  hasResponded() {
+    return this.#responded;
+  }
+};
+var InstallEvent = class extends ExtendableEvent {
+  constructor(eventInitDict) {
+    super("install", eventInitDict);
+  }
+};
+var ActivateEvent = class extends ExtendableEvent {
+  constructor(eventInitDict) {
+    super("activate", eventInitDict);
+  }
+};
+var ShovelClient = class {
+  frameType;
+  id;
+  type;
+  url;
+  constructor(options) {
+    this.frameType = "none";
+    this.id = options.id;
+    this.url = options.url;
+    this.type = options.type || "worker";
+  }
+  // Implementation
+  postMessage(_message, _transferOrOptions) {
+    logger.warn(
+      "[ServiceWorker] Client.postMessage() not supported in server context"
+    );
+  }
+};
+var ShovelWindowClient = class extends ShovelClient {
+  focused;
+  visibilityState;
+  constructor(options) {
+    super({ ...options, type: "window" });
+    this.focused = options.focused || false;
+    this.visibilityState = options.visibilityState || "hidden";
+  }
+  async focus() {
+    logger.warn(
+      "[ServiceWorker] WindowClient.focus() not supported in server context"
+    );
+    return this;
+  }
+  async navigate(_url) {
+    logger.warn(
+      "[ServiceWorker] WindowClient.navigate() not supported in server context"
+    );
+    return null;
+  }
+};
+var ShovelClients = class {
+  async claim() {
+  }
+  async get(_id) {
+    return void 0;
+  }
+  async matchAll(_options) {
+    return [];
+  }
+  async openWindow(_url) {
+    logger.warn(
+      "[ServiceWorker] Clients.openWindow() not supported in server context"
+    );
+    return null;
+  }
+};
+var ExtendableMessageEvent = class extends ExtendableEvent {
+  data;
+  origin;
+  lastEventId;
+  source;
+  ports;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.data = eventInitDict?.data ?? null;
+    this.origin = eventInitDict?.origin ?? "";
+    this.lastEventId = eventInitDict?.lastEventId ?? "";
+    this.source = eventInitDict?.source ?? null;
+    this.ports = Object.freeze([...eventInitDict?.ports ?? []]);
+  }
+};
+var ShovelServiceWorker = class extends EventTarget {
+  scriptURL;
+  state;
+  // Event handlers required by Web API
+  onstatechange;
+  onerror;
+  constructor(scriptURL, state = "parsed") {
+    super();
+    this.scriptURL = scriptURL;
+    this.state = state;
+    this.onstatechange = null;
+    this.onerror = null;
+  }
+  // Implementation
+  postMessage(_message, _transferOrOptions) {
+    logger.warn(
+      "[ServiceWorker] ServiceWorker.postMessage() not implemented in server context"
+    );
+  }
+  // Internal method to update state and dispatch statechange event
+  _setState(newState) {
+    if (this.state !== newState) {
+      this.state = newState;
+      this.dispatchEvent(new Event("statechange"));
+    }
+  }
+  // Events: statechange, error
+};
+var ShovelNavigationPreloadManager = class {
+  async disable() {
+  }
+  async enable() {
+  }
+  async getState() {
+    return { enabled: false, headerValue: "" };
+  }
+  async setHeaderValue(_value) {
+  }
+};
+var ShovelServiceWorkerRegistration = class extends EventTarget {
+  scope;
+  updateViaCache;
+  navigationPreload;
+  // ServiceWorker instances representing different lifecycle states
+  _serviceWorker;
+  // Web API properties (not supported in server context, but required by interface)
+  cookies;
+  pushManager;
+  onupdatefound;
+  constructor(scope2 = "/", scriptURL = "/") {
+    super();
+    this.scope = scope2;
+    this.updateViaCache = "imports";
+    this.navigationPreload = new ShovelNavigationPreloadManager();
+    this._serviceWorker = new ShovelServiceWorker(scriptURL, "parsed");
+    this.cookies = null;
+    this.pushManager = null;
+    this.onupdatefound = null;
+  }
+  // Standard ServiceWorkerRegistration properties
+  get active() {
+    return this._serviceWorker.state === "activated" ? this._serviceWorker : null;
+  }
+  get installing() {
+    return this._serviceWorker.state === "installing" ? this._serviceWorker : null;
+  }
+  get waiting() {
+    return this._serviceWorker.state === "installed" ? this._serviceWorker : null;
+  }
+  // Standard ServiceWorkerRegistration methods
+  async getNotifications(_options) {
+    return [];
+  }
+  async showNotification(_title, _options) {
+    logger.warn(
+      "[ServiceWorker] Notifications not supported in server context"
+    );
+  }
+  async sync() {
+  }
+  async unregister() {
+    return false;
+  }
+  async update() {
+    return this;
+  }
+  // Shovel runtime extensions (non-standard but needed for platforms)
+  /**
+   * Install the ServiceWorker (Shovel extension)
+   */
+  async install() {
+    if (this._serviceWorker.state !== "parsed")
+      return;
+    this._serviceWorker._setState("installing");
+    return new Promise((resolve, reject) => {
+      const event = new InstallEvent();
+      process.nextTick(() => {
+        try {
+          this.dispatchEvent(event);
+        } catch (error) {
+          process.nextTick(() => {
+            throw error;
+          });
+        }
+        const promises = event.getPromises();
+        if (promises.length === 0) {
+          this._serviceWorker._setState("installed");
+          resolve();
+        } else {
+          promiseWithTimeout(
+            Promise.all(promises),
+            3e4,
+            "ServiceWorker install event timed out after 30s - waitUntil promises did not resolve"
+          ).then(() => {
+            this._serviceWorker._setState("installed");
+            resolve();
+          }).catch(reject);
+        }
+      });
+    });
+  }
+  /**
+   * Activate the ServiceWorker (Shovel extension)
+   */
+  async activate() {
+    if (this._serviceWorker.state !== "installed") {
+      throw new Error("ServiceWorker must be installed before activation");
+    }
+    this._serviceWorker._setState("activating");
+    return new Promise((resolve, reject) => {
+      const event = new ActivateEvent();
+      process.nextTick(() => {
+        try {
+          this.dispatchEvent(event);
+        } catch (error) {
+          process.nextTick(() => {
+            throw error;
+          });
+        }
+        const promises = event.getPromises();
+        if (promises.length === 0) {
+          this._serviceWorker._setState("activated");
+          resolve();
+        } else {
+          promiseWithTimeout(
+            Promise.all(promises),
+            3e4,
+            "ServiceWorker activate event timed out after 30s - waitUntil promises did not resolve"
+          ).then(() => {
+            this._serviceWorker._setState("activated");
+            resolve();
+          }).catch(reject);
+        }
+      });
+    });
+  }
+  /**
+   * Handle a fetch request (Shovel extension)
+   */
+  async handleRequest(request) {
+    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]();
+      if (!event.hasResponded()) {
+        throw new Error(
+          "No response provided for fetch event. respondWith() must be called synchronously during event dispatch."
+        );
+      }
+      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);
+        for (const setCookie of setCookieHeaders) {
+          headers.append("Set-Cookie", setCookie);
+        }
+        return new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers
+        });
+      }
+      return response;
+    });
+  }
+  /**
+   * Check if ready to handle requests (Shovel extension)
+   */
+  get ready() {
+    return this._serviceWorker.state === "activated";
+  }
+  // Events: updatefound (standard), plus Shovel lifecycle events
+};
+var ShovelServiceWorkerContainer = class extends EventTarget {
+  #registrations;
+  controller;
+  ready;
+  // Event handlers required by Web API
+  oncontrollerchange;
+  onmessage;
+  onmessageerror;
+  constructor() {
+    super();
+    this.#registrations = /* @__PURE__ */ new Map();
+    this.controller = null;
+    this.oncontrollerchange = null;
+    this.onmessage = null;
+    this.onmessageerror = null;
+    const defaultRegistration = new ShovelServiceWorkerRegistration("/", "/");
+    this.#registrations.set("/", defaultRegistration);
+    this.ready = Promise.resolve(defaultRegistration);
+  }
+  /**
+   * Get registration for a specific scope
+   */
+  async getRegistration(scope2 = "/") {
+    return this.#registrations.get(scope2);
+  }
+  /**
+   * Get all registrations
+   */
+  async getRegistrations() {
+    return Array.from(this.#registrations.values());
+  }
+  /**
+   * Register a new ServiceWorker for a specific scope
+   */
+  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");
+    } else {
+      registration2 = new ShovelServiceWorkerRegistration(scope2, url);
+      this.#registrations.set(scope2, registration2);
+      this.dispatchEvent(new Event("updatefound"));
+    }
+    return registration2;
+  }
+  /**
+   * Unregister a ServiceWorker registration
+   */
+  async unregister(scope2) {
+    const registration2 = this.#registrations.get(scope2);
+    if (registration2) {
+      await registration2.unregister();
+      this.#registrations.delete(scope2);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Route a request to the appropriate registration based on scope matching
+   */
+  async handleRequest(request) {
+    const url = new URL(request.url);
+    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);
+      }
+    }
+    return null;
+  }
+  /**
+   * Install and activate all registrations
+   */
+  async installAll() {
+    const installations = Array.from(this.#registrations.values()).map(
+      async (registration2) => {
+        await registration2.install();
+        await registration2.activate();
+      }
+    );
+    await promiseWithTimeout(
+      Promise.all(installations),
+      65e3,
+      "ServiceWorker installAll timed out after 65s - some registrations failed to install/activate"
+    );
+  }
+  /**
+   * Get list of all scopes
+   */
+  getScopes() {
+    return Array.from(this.#registrations.keys());
+  }
+  startMessages() {
+  }
+  /**
+   * Normalize scope to ensure it starts and ends correctly
+   */
+  #normalizeScope(scope2) {
+    if (!scope2.startsWith("/")) {
+      scope2 = "/" + scope2;
+    }
+    if (scope2 !== "/" && !scope2.endsWith("/")) {
+      scope2 = scope2 + "/";
+    }
+    return scope2;
+  }
+  /**
+   * Find the most specific scope that matches a pathname
+   */
+  #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;
+      }
+    }
+    return null;
+  }
+  // Events: controllerchange, message, messageerror, updatefound
+};
+var Notification = class extends EventTarget {
+  actions;
+  badge;
+  body;
+  data;
+  dir;
+  icon;
+  image;
+  lang;
+  renotify;
+  requireInteraction;
+  silent;
+  tag;
+  timestamp;
+  title;
+  vibrate;
+  // Event handlers required by Web API
+  onclick;
+  onclose;
+  onerror;
+  onshow;
+  static permission;
+  constructor(title, options = {}) {
+    super();
+    this.title = title;
+    this.actions = Object.freeze([...options.actions || []]);
+    this.badge = options.badge || "";
+    this.body = options.body || "";
+    this.data = options.data;
+    this.dir = options.dir || "auto";
+    this.icon = options.icon || "";
+    this.image = options.image || "";
+    this.lang = options.lang || "";
+    this.renotify = options.renotify || false;
+    this.requireInteraction = options.requireInteraction || false;
+    this.silent = options.silent || false;
+    this.tag = options.tag || "";
+    this.timestamp = options.timestamp || Date.now();
+    this.vibrate = Object.freeze([...options.vibrate || []]);
+    this.onclick = null;
+    this.onclose = null;
+    this.onerror = null;
+    this.onshow = null;
+  }
+  close() {
+    logger.warn(
+      "[ServiceWorker] Notification.close() not supported in server context"
+    );
+  }
+  static async requestPermission() {
+    return "denied";
+  }
+  // Events: click, close, error, show
+};
+Notification.permission = "denied";
+var NotificationEvent = class extends ExtendableEvent {
+  action;
+  notification;
+  reply;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.action = eventInitDict.action ?? "";
+    this.notification = eventInitDict.notification;
+    this.reply = eventInitDict.reply ?? null;
+  }
+};
+var PushEvent = class extends ExtendableEvent {
+  data;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.data = eventInitDict?.data ?? null;
+  }
+};
+var ShovelPushMessageData = class {
+  constructor(_data) {
+    this._data = _data;
+  }
+  arrayBuffer() {
+    if (this._data instanceof ArrayBuffer) {
+      return this._data;
+    }
+    return new TextEncoder().encode(this._data).buffer;
+  }
+  blob() {
+    return new Blob([this.arrayBuffer()]);
+  }
+  bytes() {
+    return new Uint8Array(this.arrayBuffer());
+  }
+  json() {
+    return JSON.parse(this.text());
+  }
+  text() {
+    if (typeof this._data === "string") {
+      return this._data;
+    }
+    return new TextDecoder().decode(this._data);
+  }
+};
+var SyncEvent = class extends ExtendableEvent {
+  tag;
+  lastChance;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.tag = eventInitDict.tag;
+    this.lastChance = eventInitDict.lastChance ?? false;
+  }
+};
+var WorkerGlobalScope = class {
+};
+var DedicatedWorkerGlobalScope = class extends WorkerGlobalScope {
+};
+var ShovelGlobalScope = class {
+  // Self-reference (standard in ServiceWorkerGlobalScope)
+  // Type assertion: we provide a compatible subset of WorkerGlobalScope
+  self;
+  // ServiceWorker standard properties
+  // Our custom ServiceWorkerRegistration provides core functionality compatible with the Web API
+  registration;
+  // Storage APIs
+  caches;
+  buckets;
+  // Clients API
+  // Our custom Clients implementation provides core functionality compatible with the Web API
+  clients;
+  // Shovel-specific development features
+  #isDevelopment;
+  // 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
+  get cookieStore() {
+    return cookieStoreStorage.get();
+  }
+  serviceWorker;
+  // WorkerGlobalScope required properties (stubs for server context)
+  location;
+  navigator;
+  fonts;
+  indexedDB;
+  isSecureContext;
+  crossOriginIsolated;
+  origin;
+  performance;
+  crypto;
+  // WorkerGlobalScope methods (stubs for server context)
+  importScripts(..._urls) {
+    logger.warn(
+      "[ServiceWorker] importScripts() not supported in server context"
+    );
+  }
+  atob(data) {
+    return globalThis.atob(data);
+  }
+  btoa(data) {
+    return globalThis.btoa(data);
+  }
+  clearInterval(id) {
+    globalThis.clearInterval(id);
+  }
+  clearTimeout(id) {
+    globalThis.clearTimeout(id);
+  }
+  createImageBitmap(..._args) {
+    throw new Error(
+      "[ServiceWorker] createImageBitmap() not supported in server context"
+    );
+  }
+  fetch(input, init) {
+    return globalThis.fetch(input, init);
+  }
+  queueMicrotask(callback) {
+    globalThis.queueMicrotask(callback);
+  }
+  reportError(e) {
+    logger.error("[ServiceWorker] reportError:", e);
+  }
+  setInterval(handler, timeout, ...args) {
+    return globalThis.setInterval(handler, timeout, ...args);
+  }
+  setTimeout(handler, timeout, ...args) {
+    return globalThis.setTimeout(handler, timeout, ...args);
+  }
+  structuredClone(value, options) {
+    return globalThis.structuredClone(value, options);
+  }
+  // Event handlers required by ServiceWorkerGlobalScope
+  // Use Web API types (not our custom implementations) for event handler signatures
+  onactivate;
+  oncookiechange;
+  onfetch;
+  oninstall;
+  onmessage;
+  onmessageerror;
+  onnotificationclick;
+  onnotificationclose;
+  onpush;
+  onpushsubscriptionchange;
+  onsync;
+  // WorkerGlobalScope event handlers (inherited by ServiceWorkerGlobalScope)
+  onerror;
+  onlanguagechange;
+  onoffline;
+  ononline;
+  onrejectionhandled;
+  onunhandledrejection;
+  constructor(options) {
+    this.self = this;
+    this.registration = options.registration;
+    this.caches = options.caches;
+    this.buckets = options.buckets;
+    this.#isDevelopment = options.isDevelopment ?? false;
+    this.clients = this.#createClientsAPI();
+    this.serviceWorker = null;
+    this.location = {};
+    this.navigator = {};
+    this.fonts = {};
+    this.indexedDB = {};
+    this.isSecureContext = true;
+    this.crossOriginIsolated = false;
+    this.origin = "";
+    this.performance = {};
+    this.crypto = {};
+    this.onactivate = null;
+    this.oncookiechange = null;
+    this.onfetch = null;
+    this.oninstall = null;
+    this.onmessage = null;
+    this.onmessageerror = null;
+    this.onnotificationclick = null;
+    this.onnotificationclose = null;
+    this.onpush = null;
+    this.onpushsubscriptionchange = null;
+    this.onsync = null;
+    this.onerror = null;
+    this.onlanguagechange = null;
+    this.onoffline = null;
+    this.ononline = null;
+    this.onrejectionhandled = null;
+    this.onunhandledrejection = null;
+  }
+  /**
+   * Standard ServiceWorker skipWaiting() implementation
+   * Allows the ServiceWorker to activate immediately
+   */
+  async skipWaiting() {
+    logger.info("[ServiceWorker] skipWaiting() called");
+    if (!this.#isDevelopment) {
+      logger.info(
+        "[ServiceWorker] skipWaiting() - production graceful restart not implemented"
+      );
+    }
+  }
+  /**
+   * Event target delegation to registration
+   */
+  addEventListener(type, listener, options) {
+    if (listener) {
+      this.registration.addEventListener(type, listener, options);
+    }
+  }
+  removeEventListener(type, listener, options) {
+    if (listener) {
+      this.registration.removeEventListener(type, listener, options);
+    }
+  }
+  dispatchEvent(event) {
+    return this.registration.dispatchEvent(event);
+  }
+  /**
+   * Create Clients API implementation
+   * Note: HTTP requests are stateless, so most client operations are no-ops
+   */
+  #createClientsAPI() {
+    return new ShovelClients();
+  }
+  /**
+   * Install this scope as the global scope
+   * Sets up globalThis with all ServiceWorker globals
+   */
+  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);
+    }
+  };
+  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 loadedVersion = 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 });
+    const response = new Response("ServiceWorker request failed", {
+      status: 500
+    });
+    return response;
+  }
+}
+async function loadServiceWorker(version, entrypoint) {
+  try {
+    logger.debug("loadServiceWorker called", {
+      version,
+      loadedVersion
+    });
+    if (!entrypoint) {
+      throw new Error(
+        "ServiceWorker entrypoint must be provided via loadServiceWorker() call"
+      );
+    }
+    logger.info("[Worker] Loading from", { entrypoint });
+    if (loadedVersion !== null && loadedVersion !== version) {
+      logger.info(
+        `[Worker] Hot reload detected: ${loadedVersion} -> ${version}`
+      );
+      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 ShovelGlobalScope({
+        registration,
+        caches,
+        buckets
+      });
+      scope.install();
+      _workerSelf = scope;
+      currentApp = null;
+      serviceWorkerReady = false;
+    }
+    if (loadedVersion === version) {
+      logger.info("[Worker] ServiceWorker already loaded for version", {
+        version
+      });
+      return;
+    }
+    const appModule = await import(`${entrypoint}?v=${version}`);
+    loadedVersion = version;
+    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 (v${version}) 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 {
+    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 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.version, loadMsg.entrypoint);
+      sendMessage({ type: "ready", version: loadMsg.version });
+    } 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 responseMsg = {
+        type: "response",
+        response: {
+          status: response.status,
+          statusText: response.statusText,
+          headers: Object.fromEntries(response.headers.entries()),
+          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);
+  });
+}
+export {
+  ActivateEvent,
+  DedicatedWorkerGlobalScope,
+  ExtendableEvent,
+  ExtendableMessageEvent,
+  FetchEvent,
+  InstallEvent,
+  Notification,
+  NotificationEvent,
+  PushEvent,
+  ShovelClient,
+  ShovelClients,
+  ShovelGlobalScope,
+  ShovelNavigationPreloadManager,
+  ShovelPushMessageData,
+  ShovelServiceWorker,
+  ShovelServiceWorkerContainer,
+  ShovelServiceWorkerRegistration,
+  ShovelWindowClient,
+  SyncEvent,
+  WorkerGlobalScope
+};