lucent-pack 0.1.0__py3-none-any.whl

lucent_pack/static/lucent/dist/httpuv-sw.js

@@ -0,0 +1,1478 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/httpuv/constants.ts
+var WS_FRAME = {
+  SEND: "websocket.send"};
+var WASM_R_HOME = "/lib/R";
+var REQUEST_TIMEOUT_MS = 18e4;
+var MSG = {
+  REGISTER_HOST: "httpuv_register_host",
+  HTTP_REQUEST: "httpuv_http_request",
+  HTTP_RESPONSE: "httpuv_http_response",
+  WS_PUSH: "httpuv_ws_push",
+  /** Iframe → SW (on session port): frame delivered to Shiny.createSocket. */
+  WS_PUSH_ACK: "httpuv_ws_push_ack",
+  STOP: "httpuv_stop",
+  /** Drop cached GET /shiny/ without tearing down the R worker (app restart). */
+  CLEAR_APP_CACHE: "httpuv_clear_app_cache",
+  /** Host -> SW: full shiny::resourcePaths() map (warmup). */
+  REGISTER_RESOURCE_PATHS: "httpuv_register_resource_paths",
+  /** Host -> SW: upsert or remove one addResourcePath prefix (empty dir removes). */
+  UPDATE_RESOURCE_PATH: "httpuv_update_resource_path",
+  /** SW -> host: Comlink to the R worker was lost (e.g. after SW update). */
+  REQUEST_COMLINK: "httpuv_request_comlink",
+  /** Iframe → SW: transfer a MessagePort for session WS push delivery. */
+  REGISTER_SESSION: "httpuv_register_session",
+  /** SW → iframe (on session port): registration accepted. */
+  SESSION_ACK: "httpuv_session_ack",
+  /** SW → iframe client: session MessagePort was lost (e.g. SW idle restart); re-REGISTER_SESSION. */
+  REQUEST_SESSION_PORT: "httpuv_request_session_port"
+};
+var WARMUP_REQUEST_HEADER = "X-Shiny-Forge-Warmup";
+var COMLINK = {
+  PORT_HANDOFF: "httpuv_comlink_port",
+  /**
+   * SW -> host: the handoff port arrived. Sent before the Comlink round-trip so
+   * the host can distinguish a dropped handoff (worker evicted mid-boot) from an
+   * R worker that never finished setup.
+   */
+  PORT_HANDOFF_ACK: "httpuv_comlink_port_ack"
+};
+
+// node_modules/comlink/dist/esm/comlink.mjs
+var comlink_exports = {};
+__export(comlink_exports, {
+  createEndpoint: () => createEndpoint,
+  expose: () => expose,
+  finalizer: () => finalizer,
+  proxy: () => proxy,
+  proxyMarker: () => proxyMarker,
+  releaseProxy: () => releaseProxy,
+  transfer: () => transfer,
+  transferHandlers: () => transferHandlers,
+  windowEndpoint: () => windowEndpoint,
+  wrap: () => wrap
+});
+var proxyMarker = /* @__PURE__ */ Symbol("Comlink.proxy");
+var createEndpoint = /* @__PURE__ */ Symbol("Comlink.endpoint");
+var releaseProxy = /* @__PURE__ */ Symbol("Comlink.releaseProxy");
+var finalizer = /* @__PURE__ */ Symbol("Comlink.finalizer");
+var throwMarker = /* @__PURE__ */ Symbol("Comlink.thrown");
+var isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+var proxyTransferHandler = {
+  canHandle: (val) => isObject(val) && val[proxyMarker],
+  serialize(obj) {
+    const { port1, port2 } = new MessageChannel();
+    expose(obj, port1);
+    return [port2, [port2]];
+  },
+  deserialize(port) {
+    port.start();
+    return wrap(port);
+  }
+};
+var throwTransferHandler = {
+  canHandle: (value) => isObject(value) && throwMarker in value,
+  serialize({ value }) {
+    let serialized;
+    if (value instanceof Error) {
+      serialized = {
+        isError: true,
+        value: {
+          message: value.message,
+          name: value.name,
+          stack: value.stack
+        }
+      };
+    } else {
+      serialized = { isError: false, value };
+    }
+    return [serialized, []];
+  },
+  deserialize(serialized) {
+    if (serialized.isError) {
+      throw Object.assign(new Error(serialized.value.message), serialized.value);
+    }
+    throw serialized.value;
+  }
+};
+var transferHandlers = /* @__PURE__ */ new Map([
+  ["proxy", proxyTransferHandler],
+  ["throw", throwTransferHandler]
+]);
+function isAllowedOrigin(allowedOrigins, origin) {
+  for (const allowedOrigin of allowedOrigins) {
+    if (origin === allowedOrigin || allowedOrigin === "*") {
+      return true;
+    }
+    if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+      return true;
+    }
+  }
+  return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+  ep.addEventListener("message", function callback(ev) {
+    if (!ev || !ev.data) {
+      return;
+    }
+    if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+      console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+      return;
+    }
+    const { id, type, path } = Object.assign({ path: [] }, ev.data);
+    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+    let returnValue;
+    try {
+      const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+      const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+      switch (type) {
+        case "GET":
+          {
+            returnValue = rawValue;
+          }
+          break;
+        case "SET":
+          {
+            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+            returnValue = true;
+          }
+          break;
+        case "APPLY":
+          {
+            returnValue = rawValue.apply(parent, argumentList);
+          }
+          break;
+        case "CONSTRUCT":
+          {
+            const value = new rawValue(...argumentList);
+            returnValue = proxy(value);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1, port2 } = new MessageChannel();
+            expose(obj, port2);
+            returnValue = transfer(port1, [port1]);
+          }
+          break;
+        case "RELEASE":
+          {
+            returnValue = void 0;
+          }
+          break;
+        default:
+          return;
+      }
+    } catch (value) {
+      returnValue = { value, [throwMarker]: 0 };
+    }
+    Promise.resolve(returnValue).catch((value) => {
+      return { value, [throwMarker]: 0 };
+    }).then((returnValue2) => {
+      const [wireValue, transferables] = toWireValue(returnValue2);
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      if (type === "RELEASE") {
+        ep.removeEventListener("message", callback);
+        closeEndPoint(ep);
+        if (finalizer in obj && typeof obj[finalizer] === "function") {
+          obj[finalizer]();
+        }
+      }
+    }).catch((error) => {
+      const [wireValue, transferables] = toWireValue({
+        value: new TypeError("Unserializable return value"),
+        [throwMarker]: 0
+      });
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+    });
+  });
+  if (ep.start) {
+    ep.start();
+  }
+}
+function isMessagePort(endpoint) {
+  return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+  if (isMessagePort(endpoint))
+    endpoint.close();
+}
+function wrap(ep, target) {
+  const pendingListeners = /* @__PURE__ */ new Map();
+  ep.addEventListener("message", function handleMessage(ev) {
+    const { data } = ev;
+    if (!data || !data.id) {
+      return;
+    }
+    const resolver = pendingListeners.get(data.id);
+    if (!resolver) {
+      return;
+    }
+    try {
+      resolver(data);
+    } finally {
+      pendingListeners.delete(data.id);
+    }
+  });
+  return createProxy(ep, pendingListeners, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+  if (isReleased) {
+    throw new Error("Proxy has been released and is not useable");
+  }
+}
+function releaseEndpoint(ep) {
+  return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    closeEndPoint(ep);
+  });
+}
+var proxyCounter = /* @__PURE__ */ new WeakMap();
+var proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+  const newCount = (proxyCounter.get(ep) || 0) - 1;
+  proxyCounter.set(ep, newCount);
+  if (newCount === 0) {
+    releaseEndpoint(ep);
+  }
+});
+function registerProxy(proxy2, ep) {
+  const newCount = (proxyCounter.get(ep) || 0) + 1;
+  proxyCounter.set(ep, newCount);
+  if (proxyFinalizers) {
+    proxyFinalizers.register(proxy2, ep, proxy2);
+  }
+}
+function unregisterProxy(proxy2) {
+  if (proxyFinalizers) {
+    proxyFinalizers.unregister(proxy2);
+  }
+}
+function createProxy(ep, pendingListeners, path = [], target = function() {
+}) {
+  let isProxyReleased = false;
+  const proxy2 = new Proxy(target, {
+    get(_target, prop) {
+      throwIfProxyReleased(isProxyReleased);
+      if (prop === releaseProxy) {
+        return () => {
+          unregisterProxy(proxy2);
+          releaseEndpoint(ep);
+          pendingListeners.clear();
+          isProxyReleased = true;
+        };
+      }
+      if (prop === "then") {
+        if (path.length === 0) {
+          return { then: () => proxy2 };
+        }
+        const r = requestResponseMessage(ep, pendingListeners, {
+          type: "GET",
+          path: path.map((p) => p.toString())
+        }).then(fromWireValue);
+        return r.then.bind(r);
+      }
+      return createProxy(ep, pendingListeners, [...path, prop]);
+    },
+    set(_target, prop, rawValue) {
+      throwIfProxyReleased(isProxyReleased);
+      const [value, transferables] = toWireValue(rawValue);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "SET",
+        path: [...path, prop].map((p) => p.toString()),
+        value
+      }, transferables).then(fromWireValue);
+    },
+    apply(_target, _thisArg, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const last = path[path.length - 1];
+      if (last === createEndpoint) {
+        return requestResponseMessage(ep, pendingListeners, {
+          type: "ENDPOINT"
+        }).then(fromWireValue);
+      }
+      if (last === "bind") {
+        return createProxy(ep, pendingListeners, path.slice(0, -1));
+      }
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "APPLY",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    },
+    construct(_target, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
+        type: "CONSTRUCT",
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
+    }
+  });
+  registerProxy(proxy2, ep);
+  return proxy2;
+}
+function myFlat(arr) {
+  return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+  const processed = argumentList.map(toWireValue);
+  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+var transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+  transferCache.set(obj, transfers);
+  return obj;
+}
+function proxy(obj) {
+  return Object.assign(obj, { [proxyMarker]: true });
+}
+function windowEndpoint(w, context = globalThis, targetOrigin = "*") {
+  return {
+    postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),
+    addEventListener: context.addEventListener.bind(context),
+    removeEventListener: context.removeEventListener.bind(context)
+  };
+}
+function toWireValue(value) {
+  for (const [name, handler] of transferHandlers) {
+    if (handler.canHandle(value)) {
+      const [serializedValue, transferables] = handler.serialize(value);
+      return [
+        {
+          type: "HANDLER",
+          name,
+          value: serializedValue
+        },
+        transferables
+      ];
+    }
+  }
+  return [
+    {
+      type: "RAW",
+      value
+    },
+    transferCache.get(value) || []
+  ];
+}
+function fromWireValue(value) {
+  switch (value.type) {
+    case "HANDLER":
+      return transferHandlers.get(value.name).deserialize(value.value);
+    case "RAW":
+      return value.value;
+  }
+}
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+  return new Promise((resolve) => {
+    const id = generateUUID();
+    pendingListeners.set(id, resolve);
+    if (ep.start) {
+      ep.start();
+    }
+    ep.postMessage(Object.assign({ id }, msg), transfers);
+  });
+}
+function generateUUID() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+
+// src/httpuv/comlink.ts
+function createSwDeliveryApi(deliverOutbound) {
+  return {
+    deliverHttpResponse(resp) {
+      deliverOutbound({
+        type: MSG.HTTP_RESPONSE,
+        uuid: resp.uuid,
+        status: resp.status ?? 500,
+        headers: resp.headers ?? {},
+        body: resp.body ?? null
+      });
+    }
+  };
+}
+
+// src/httpuv/debug.ts
+function isHttpuvDebug() {
+  if (globalThis.__HTTPUV_DEBUG__) {
+    return true;
+  }
+  try {
+    if (typeof location !== "undefined") {
+      const params = new URLSearchParams(location.search);
+      if (params.has("httpuvDebug") || params.get("debug") === "httpuv") {
+        return true;
+      }
+    }
+    if (typeof localStorage !== "undefined" && localStorage.getItem("shinyForgeDebug") === "1") {
+      return true;
+    }
+    if (typeof self !== "undefined" && self.location?.href) {
+      const params = new URL(self.location.href).searchParams;
+      if (params.has("httpuvDebug") || params.get("debug") === "httpuv") {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function httpuvDebugLog(stage, ...args) {
+  if (!isHttpuvDebug()) {
+    return;
+  }
+  console.info(`[httpuv-debug:${stage}]`, ...args);
+}
+
+// src/httpuv/prefix.ts
+function resolveShinyPrefix(fromUrl) {
+  const prefix = new URL("shiny/", fromUrl).pathname;
+  return prefix.endsWith("/") ? prefix : `${prefix}/`;
+}
+var SESSION_DIR = "__session__";
+var HOST_DIR = "__host__";
+function normalizeSessionHandle(handle) {
+  let s = String(handle ?? "").trim();
+  while (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+    s = s.slice(1, -1);
+  }
+  return s;
+}
+function resolveSessionPrefix(fromUrl) {
+  return `${resolveShinyPrefix(fromUrl)}${SESSION_DIR}/`;
+}
+function parseSessionAction(urlString, prefix) {
+  const url = new URL(urlString);
+  const sessionPrefix = `${prefix}${SESSION_DIR}/`;
+  if (!url.pathname.startsWith(sessionPrefix)) {
+    return null;
+  }
+  const action = url.pathname.slice(sessionPrefix.length).replace(/\/$/, "");
+  if (!["open", "send", "recv", "close"].includes(action)) {
+    return null;
+  }
+  const rawHandle = url.searchParams.get("handle");
+  return {
+    action,
+    handle: rawHandle ? normalizeSessionHandle(rawHandle) : null
+  };
+}
+function isHostPushUrl(urlString, prefix) {
+  const url = new URL(urlString);
+  return url.pathname === `${prefix}${HOST_DIR}/push`;
+}
+
+// src/httpuv/htmlwidget-deps-patch.ts
+var LUCENT_PATCH_VERSION = "htmlwidget-async-v2";
+var HTMLWIDGET_ASYNC_DEPS_PATCH = `<script id="lucent-htmlwidget-async-deps">(function(){
+window.__lucentEvalCache=window.__lucentEvalCache||{};
+function cacheScript(url,text){
+  try{
+    var abs=new URL(url,document.baseURI).href;
+    window.__lucentEvalCache[abs]=text;
+    window.__lucentEvalCache[url]=text;
+  }catch(e){}
+}
+(function(){
+  var ofetch=window.fetch;
+  if(!ofetch)return;
+  var oAppend=Element.prototype.appendChild;
+  Element.prototype.appendChild=function(node){
+    if(node&&node.tagName==='SCRIPT'&&node.src){
+      var src=node.src;
+      ofetch(src).then(function(r){return r.ok?r.text():null;}).then(function(t){if(t)cacheScript(src,t);}).catch(function(){});
+    }
+    return oAppend.apply(this,arguments);
+  };
+})();
+function installEvalUrlPatch(){
+  if(!window.jQuery||!jQuery._evalUrl||jQuery._evalUrl.__lucentPatched)return;
+  var orig=jQuery._evalUrl;
+  jQuery._evalUrl=function(url,options,doc){
+    var abs;
+    try{abs=new URL(url,document.baseURI).href;}catch(e){abs=url;}
+    var cached=window.__lucentEvalCache[abs]||window.__lucentEvalCache[url];
+    if(typeof cached==='string'){
+      jQuery.globalEval(cached,options,doc);
+      return {status:200,responseText:cached};
+    }
+    return orig.apply(this,arguments);
+  };
+  jQuery._evalUrl.__lucentPatched=1;
+}
+function wrap(binding){
+  if(!binding||!binding.renderValue||binding.__lucentAsyncDeps)return;
+  binding.__lucentAsyncDeps=1;
+  try{
+    if(binding.renderValue.constructor&&binding.renderValue.constructor.name==='AsyncFunction')return;
+  }catch(e){}
+  var rv=binding.renderValue.bind(binding);
+  binding.renderValue=function(el,data){
+    if(data&&data.x!=null&&data.deps&&data.deps.length){
+      return Shiny.renderDependenciesAsync(data.deps).then(function(){return rv(el,data);});
+    }
+    return rv(el,data);
+  };
+}
+function installBindingWrap(){
+  if(!window.Shiny||!Shiny.outputBindings||!Shiny.renderDependenciesAsync)return;
+  if(!Shiny.outputBindings.__lucentAsyncDepsReg){
+    Shiny.outputBindings.__lucentAsyncDepsReg=1;
+    var reg=Shiny.outputBindings.register.bind(Shiny.outputBindings);
+    Shiny.outputBindings.register=function(binding,name){
+      wrap(binding);
+      return reg(binding,name);
+    };
+  }
+  var list=Shiny.outputBindings.getBindings?Shiny.outputBindings.getBindings():[];
+  for(var i=0;i<list.length;i++){
+    wrap(list[i].binding||list[i]);
+  }
+}
+function install(){
+  installEvalUrlPatch();
+  installBindingWrap();
+}
+install();
+var n=0,t=setInterval(function(){install();if(++n>400)clearInterval(t);},5);
+})();<\/script>`;
+function responseBodyToText(body) {
+  if (body == null) {
+    return null;
+  }
+  if (typeof body === "string") {
+    return body;
+  }
+  if (body instanceof ArrayBuffer) {
+    return new TextDecoder().decode(body);
+  }
+  if (ArrayBuffer.isView(body)) {
+    return new TextDecoder().decode(body);
+  }
+  return null;
+}
+function isHtmlContentType(headers) {
+  if (!headers) {
+    return false;
+  }
+  const ct = headers["content-type"] ?? headers["Content-Type"] ?? "";
+  return ct.includes("text/html");
+}
+function injectHtmlwidgetAsyncDepsPatch(html) {
+  let out = html.replace(/<script id="lucent-htmlwidget-async-deps"[\s\S]*?<\/script>\s*/g, "");
+  const patch = HTMLWIDGET_ASYNC_DEPS_PATCH.replace(
+    'id="lucent-htmlwidget-async-deps"',
+    `id="lucent-htmlwidget-async-deps" data-lucent-patch="${LUCENT_PATCH_VERSION}"`
+  );
+  const shinyScript = out.match(/<script src="[^"]*\/shiny(?:\.min)?\.js"><\/script>/);
+  if (shinyScript) {
+    return out.replace(shinyScript[0], `${shinyScript[0]}
+${patch}`);
+  }
+  if (out.includes("<head>")) {
+    return out.replace("<head>", `<head>
+${patch}`);
+  }
+  if (out.includes("</head>")) {
+    return out.replace("</head>", `${patch}
+</head>`);
+  }
+  return patch + out;
+}
+function maybePatchAppDocumentResponse(resp, url, method, isAppDocument) {
+  if (method !== "GET" || resp.status !== 200 || !isAppDocument(url) || !isHtmlContentType(resp.headers)) {
+    return resp;
+  }
+  const html = responseBodyToText(resp.body);
+  if (!html || !html.includes("htmlwidgets")) {
+    return resp;
+  }
+  const patched = injectHtmlwidgetAsyncDepsPatch(html);
+  if (patched === html) {
+    return resp;
+  }
+  return {
+    status: resp.status,
+    headers: resp.headers,
+    body: patched
+  };
+}
+
+// src/httpuv/sw.ts
+var swSelf = self;
+function initialShinyPrefix() {
+  try {
+    const own = new URL(swSelf.location.href);
+    const declared = own.searchParams.get("shinyPrefix");
+    if (declared) {
+      return declared.endsWith("/") ? declared : `${declared}/`;
+    }
+  } catch {
+  }
+  return resolveShinyPrefix(new URL("/", swSelf.location.href).href);
+}
+var SHINY_PREFIX = initialShinyPrefix();
+resolveSessionPrefix(new URL("/", swSelf.location.href).href);
+var shinyAppPrefix = SHINY_PREFIX;
+var hostClientId = null;
+var rwasmHost = null;
+function createRwasmHostReady() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+var rwasmHostReady = createRwasmHostReady();
+async function connectSwToWorker(port) {
+  const workerHost = comlink_exports.wrap(port);
+  const deliveryChannel = new MessageChannel();
+  const wsPushChannel = new MessageChannel();
+  comlink_exports.expose(
+    createSwDeliveryApi((msg) => handleHostOutboundMessage(msg)),
+    deliveryChannel.port1
+  );
+  wsPushChannel.port1.onmessage = (event) => {
+    const msg = event.data;
+    if (!msg || typeof msg !== "object" || typeof msg.type !== "string") {
+      return;
+    }
+    handleHostOutboundMessage(msg);
+  };
+  wsPushChannel.port1.start();
+  try {
+    await workerHost.registerSwDelivery(
+      comlink_exports.transfer(deliveryChannel.port2, [deliveryChannel.port2]),
+      comlink_exports.transfer(wsPushChannel.port2, [wsPushChannel.port2])
+    );
+    rwasmHost = workerHost;
+    markRwasmHostReady();
+    httpuvDebugLog("sw-comlink-connected");
+  } catch (err) {
+    console.error("[httpuv-sw] Comlink unified setup failed", err);
+    const message = err instanceof Error ? err.message : String(err);
+    resetRwasmHostWaiter(new Error(`R worker Comlink setup failed: ${message}`));
+  }
+}
+function markRwasmHostReady() {
+  if (!rwasmHost) {
+    return;
+  }
+  rwasmHostReady.resolve(rwasmHost);
+}
+function resetRwasmHostWaiter(reason) {
+  const previous = rwasmHostReady;
+  rwasmHost = null;
+  rwasmHostReady = createRwasmHostReady();
+  previous.reject(reason ?? new Error("R worker Comlink not ready"));
+}
+function rollRwasmHostWaiter() {
+  const previous = rwasmHostReady;
+  rwasmHost = null;
+  rwasmHostReady = createRwasmHostReady();
+  void rwasmHostReady.promise.then(
+    (host) => {
+      previous.resolve(host);
+    },
+    (err) => {
+      previous.reject(err instanceof Error ? err : new Error(String(err)));
+    }
+  );
+}
+async function waitForRwasmHost() {
+  for (; ; ) {
+    if (rwasmHost) {
+      return rwasmHost;
+    }
+    const ready = rwasmHostReady;
+    try {
+      return await ready.promise;
+    } catch (err) {
+      if (rwasmHost) {
+        return rwasmHost;
+      }
+      if (rwasmHostReady !== ready) {
+        continue;
+      }
+      throw err;
+    }
+  }
+}
+async function requestComlinkFromHost() {
+  const clients = await swSelf.clients.matchAll({
+    type: "window",
+    includeUncontrolled: true
+  });
+  httpuvDebugLog("sw-request-comlink", {
+    clients: clients.length,
+    hostClientId,
+    urls: clients.map((c) => c.url)
+  });
+  for (const client of clients) {
+    client.postMessage({ type: MSG.REQUEST_COMLINK });
+  }
+}
+var pendingHttp = /* @__PURE__ */ new Map();
+var sessionPorts = /* @__PURE__ */ new Map();
+var sessionClientIds = /* @__PURE__ */ new Map();
+var queuedWsPush = /* @__PURE__ */ new Map();
+var sessionPortReregisterPending = /* @__PURE__ */ new Set();
+var sessionDeliverChain = /* @__PURE__ */ new Map();
+var pendingSessionAcks = /* @__PURE__ */ new Map();
+var nextSessionPushId = 1;
+var SESSION_PUSH_ACK_TIMEOUT_MS = 8e3;
+var cachedAppDocument = null;
+var LUCENT_APP_PATCH_VERSION = "htmlwidget-async-v2";
+var shinyResourcePaths = /* @__PURE__ */ new Map();
+function isAppDocumentRequest(urlString) {
+  const url = new URL(urlString);
+  if (!url.pathname.startsWith(shinyAppPrefix)) {
+    return false;
+  }
+  const rest = url.pathname.slice(shinyAppPrefix.length).replace(/\/$/, "");
+  return rest === "" || rest === "index.html";
+}
+function pathUnderShinyPrefix(pathname) {
+  return pathname.startsWith(shinyAppPrefix) || pathname.startsWith(SHINY_PREFIX);
+}
+function clonePendingResponse(resp) {
+  let body = resp.body;
+  if (body instanceof ArrayBuffer) {
+    body = body.slice(0);
+  } else if (body instanceof Uint8Array) {
+    body = body.slice();
+  }
+  return {
+    status: resp.status,
+    headers: { ...resp.headers ?? {} },
+    body
+  };
+}
+function clearCachedAppDocument() {
+  cachedAppDocument = null;
+}
+function clearShinyResourcePaths() {
+  shinyResourcePaths = /* @__PURE__ */ new Map();
+}
+function setShinyResourcePaths(paths) {
+  shinyResourcePaths = /* @__PURE__ */ new Map();
+  for (const [prefix, dir] of Object.entries(paths ?? {})) {
+    if (prefix && dir) {
+      shinyResourcePaths.set(prefix, dir);
+    }
+  }
+  if (shinyResourcePaths.size > 0) {
+    httpuvDebugLog("sw-resource-paths", {
+      count: shinyResourcePaths.size,
+      keys: [...shinyResourcePaths.keys()]
+    });
+  }
+}
+function updateShinyResourcePath(prefix, dir) {
+  if (!prefix) {
+    return;
+  }
+  if (!dir) {
+    shinyResourcePaths.delete(prefix);
+  } else {
+    shinyResourcePaths.set(prefix, dir);
+  }
+  httpuvDebugLog("sw-resource-path-update", {
+    prefix,
+    dir: dir || null,
+    count: shinyResourcePaths.size
+  });
+}
+function mimeForAssetSuffix(suffix) {
+  if (suffix.endsWith(".js") || suffix.endsWith(".mjs")) {
+    return "application/javascript";
+  }
+  if (suffix.endsWith(".css")) {
+    return "text/css";
+  }
+  if (suffix.endsWith(".svg")) {
+    return "image/svg+xml";
+  }
+  if (suffix.endsWith(".png")) {
+    return "image/png";
+  }
+  if (suffix.endsWith(".woff2")) {
+    return "font/woff2";
+  }
+  if (suffix.endsWith(".woff")) {
+    return "font/woff";
+  }
+  return "application/octet-stream";
+}
+function pathnameRelativeToScope(pathname) {
+  const scopeUrl = swSelf.registration?.scope;
+  if (!scopeUrl) {
+    return pathname;
+  }
+  let scopePath = new URL(scopeUrl).pathname;
+  if (!scopePath.endsWith("/")) {
+    scopePath += "/";
+  }
+  if (scopePath !== "/" && pathname.startsWith(scopePath)) {
+    return `/${pathname.slice(scopePath.length)}`;
+  }
+  return pathname;
+}
+function vfsPathFromLibRRequest(pathname) {
+  const rest = pathnameRelativeToScope(pathname);
+  const marker = `${WASM_R_HOME}/`;
+  if (rest !== WASM_R_HOME && !rest.startsWith(marker)) {
+    return null;
+  }
+  if (rest.includes("..")) {
+    return null;
+  }
+  return rest;
+}
+function vfsStaticResponse(body, suffix, source, method) {
+  const headers = new Headers({
+    "Content-Type": mimeForAssetSuffix(suffix),
+    "X-Httpuv-Static": source
+  });
+  if (suffix.toLowerCase().endsWith(".png") || source === "vfs") {
+    headers.set("Cache-Control", "no-store");
+  }
+  if (method === "HEAD") {
+    return new Response(null, { status: 200, headers });
+  }
+  return new Response(body, { status: 200, headers });
+}
+async function tryServeLibRAsset(request) {
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    return null;
+  }
+  const url = new URL(request.url);
+  const vfsPath = vfsPathFromLibRRequest(url.pathname);
+  if (!vfsPath) {
+    return null;
+  }
+  const suffix = vfsPath.slice(vfsPath.lastIndexOf("/") + 1);
+  try {
+    if (!rwasmHost) {
+      void requestComlinkFromHost();
+    }
+    const host = await waitForRwasmHost();
+    const body = await host.readVfsFileAt(vfsPath);
+    if (!body) {
+      httpuvDebugLog("sw-vfs-read-miss", { vfsPath });
+      return null;
+    }
+    httpuvDebugLog("sw-static-hit", { vfsPath, source: "lib-r-vfs" });
+    return vfsStaticResponse(body, suffix, "lib-r-vfs", request.method);
+  } catch (err) {
+    httpuvDebugLog("sw-vfs-read-fail", { vfsPath, err: String(err) });
+    return null;
+  }
+}
+async function tryServeShinyStaticAsset(request) {
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    return null;
+  }
+  const url = new URL(request.url);
+  if (!url.pathname.startsWith(shinyAppPrefix)) {
+    return null;
+  }
+  const rest = url.pathname.slice(shinyAppPrefix.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0) {
+    return null;
+  }
+  const prefix = rest.slice(0, slash);
+  const suffix = rest.slice(slash + 1);
+  if (!suffix || suffix.includes("..")) {
+    return null;
+  }
+  const localDir = shinyResourcePaths.get(prefix);
+  if (!localDir || !rwasmHost) {
+    return null;
+  }
+  try {
+    const body = await rwasmHost.readVfsFile(localDir, suffix);
+    if (!body) {
+      httpuvDebugLog("sw-vfs-read-miss", { prefix, suffix, vfsDir: localDir });
+      return null;
+    }
+    httpuvDebugLog("sw-static-hit", { prefix, suffix, source: "vfs", path: localDir });
+    return vfsStaticResponse(body, suffix, "vfs", request.method);
+  } catch (err) {
+    httpuvDebugLog("sw-vfs-read-fail", { prefix, suffix, vfsDir: localDir, err: String(err) });
+    return null;
+  }
+}
+swSelf.addEventListener("install", (event) => {
+  httpuvDebugLog("sw-install", { shinyPrefix: SHINY_PREFIX });
+  event.waitUntil(swSelf.skipWaiting());
+});
+swSelf.addEventListener("activate", (event) => {
+  httpuvDebugLog("sw-activate", { shinyPrefix: SHINY_PREFIX });
+  resetRwasmHostWaiter();
+  event.waitUntil(
+    (async () => {
+      await swSelf.clients.claim();
+      await requestComlinkFromHost();
+    })()
+  );
+});
+function waitForHttpResponse(uuid, url, method) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pendingHttp.delete(uuid);
+      httpuvDebugLog("sw-timeout", { uuid, timeoutMs: REQUEST_TIMEOUT_MS });
+      reject(new Error(`httpuv request ${uuid} timed out after ${REQUEST_TIMEOUT_MS}ms`));
+    }, REQUEST_TIMEOUT_MS);
+    pendingHttp.set(uuid, { resolve, reject, timer, url, method });
+  });
+}
+function maybeCacheAppDocument(resp, url, method) {
+  if (url && method === "GET" && isAppDocumentRequest(url) && resp.status === 200) {
+    cachedAppDocument = clonePendingResponse(resp);
+    if (cachedAppDocument.headers) {
+      cachedAppDocument.headers["x-lucent-app-patch"] = LUCENT_APP_PATCH_VERSION;
+    }
+    httpuvDebugLog("sw-app-cache-store", { url, patch: LUCENT_APP_PATCH_VERSION });
+  }
+}
+function toFetchResponse(resp) {
+  const headers = new Headers(resp.headers ?? {});
+  if (resp.body == null) {
+    return new Response(null, { status: resp.status, headers });
+  }
+  return new Response(resp.body, { status: resp.status, headers });
+}
+async function headersToObject(request) {
+  const headers = {};
+  request.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return headers;
+}
+function messageBodyLength(message) {
+  if (typeof message === "string") {
+    return message.length;
+  }
+  if (message instanceof ArrayBuffer) {
+    return message.byteLength;
+  }
+  if (ArrayBuffer.isView(message)) {
+    return message.byteLength;
+  }
+  return 0;
+}
+function cloneWsMessage(message, binary) {
+  if (message == null) {
+    return null;
+  }
+  if (!binary) {
+    if (typeof message === "string") {
+      return message;
+    }
+    if (message instanceof ArrayBuffer) {
+      return new TextDecoder().decode(message);
+    }
+    if (ArrayBuffer.isView(message)) {
+      return new TextDecoder().decode(message);
+    }
+    return String(message);
+  }
+  if (message instanceof ArrayBuffer) {
+    return message.slice(0);
+  }
+  if (ArrayBuffer.isView(message)) {
+    return message.buffer.slice(message.byteOffset, message.byteOffset + message.byteLength);
+  }
+  if (Array.isArray(message)) {
+    return new Uint8Array(message).buffer;
+  }
+  return message;
+}
+function postWsPushToPort(port, handle, msg, pushId) {
+  const binary = Boolean(msg.binary);
+  const payload = {
+    type: MSG.WS_PUSH,
+    handle,
+    wsType: msg.wsType ?? WS_FRAME.SEND,
+    binary,
+    message: cloneWsMessage(msg.message ?? null, binary),
+    pushId
+  };
+  try {
+    port.postMessage(payload);
+    return true;
+  } catch (err) {
+    console.warn("[httpuv-sw] session port postMessage failed", err);
+    return false;
+  }
+}
+function rejectPendingSessionAcks(reason) {
+  for (const [id, pending] of pendingSessionAcks) {
+    pendingSessionAcks.delete(id);
+    pending.reject(new Error(reason));
+  }
+}
+function waitForSessionPushAck(pushId) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pendingSessionAcks.delete(pushId);
+      reject(new Error(`session WS_PUSH_ACK timed out (id=${pushId})`));
+    }, SESSION_PUSH_ACK_TIMEOUT_MS);
+    pendingSessionAcks.set(pushId, {
+      resolve: () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      reject: (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    });
+  });
+}
+function handleSessionPortInbound(key, event) {
+  const data = event.data;
+  if (!data || typeof data !== "object") {
+    return;
+  }
+  if (data.type === MSG.WS_PUSH_ACK && typeof data.pushId === "number") {
+    const pending = pendingSessionAcks.get(data.pushId);
+    if (pending) {
+      pendingSessionAcks.delete(data.pushId);
+      pending.resolve();
+    }
+    return;
+  }
+  httpuvDebugLog("sw-session-port-unknown", { handle: key, type: data.type });
+}
+function clearSessionPort(handle) {
+  const key = normalizeSessionHandle(handle);
+  const port = sessionPorts.get(key);
+  if (!port) {
+    return;
+  }
+  sessionPorts.delete(key);
+  rejectPendingSessionAcks(`session port cleared (${key})`);
+  try {
+    port.onmessage = null;
+    port.close();
+  } catch {
+  }
+}
+function requestSessionPortReregister(handle) {
+  const key = normalizeSessionHandle(handle);
+  if (!key || sessionPortReregisterPending.has(key)) {
+    return;
+  }
+  sessionPortReregisterPending.add(key);
+  const storedClientId = sessionClientIds.get(key);
+  void (async () => {
+    try {
+      let client;
+      if (storedClientId) {
+        client = await swSelf.clients.get(storedClientId);
+      }
+      if (!client) {
+        const clients = await swSelf.clients.matchAll({
+          type: "window",
+          includeUncontrolled: true
+        });
+        client = clients.find((c) => isShinyAppClientUrl(c.url)) ?? clients.find((c) => !isShinyAppClientUrl(c.url)) ?? clients[0];
+      }
+      if (!client) {
+        httpuvDebugLog("sw-session-reregister-no-client", { handle: key });
+        return;
+      }
+      httpuvDebugLog("sw-session-reregister", { handle: key, clientId: client.id });
+      client.postMessage({ type: MSG.REQUEST_SESSION_PORT, handle: key });
+    } catch (err) {
+      console.warn("[httpuv-sw] REQUEST_SESSION_PORT failed", err);
+    } finally {
+      setTimeout(() => {
+        sessionPortReregisterPending.delete(key);
+      }, 2e3);
+    }
+  })();
+}
+function queueWsPush(key, msg) {
+  const existing = queuedWsPush.get(key);
+  if (existing) {
+    existing.push(msg);
+  } else {
+    queuedWsPush.set(key, [msg]);
+  }
+}
+function registerSessionPort(handle, port, clientId) {
+  const key = normalizeSessionHandle(handle);
+  clearSessionPort(key);
+  if (clientId) {
+    sessionClientIds.set(key, clientId);
+  }
+  sessionPortReregisterPending.delete(key);
+  port.start();
+  port.onmessage = (event) => {
+    handleSessionPortInbound(key, event);
+  };
+  sessionPorts.set(key, port);
+  httpuvDebugLog("sw-session-registered", { handle: key, clientId: sessionClientIds.get(key) });
+  const queued = queuedWsPush.get(key);
+  if (queued && queued.length > 0) {
+    queuedWsPush.delete(key);
+    for (const next of queued) {
+      deliverWsPush(key, next);
+    }
+  }
+  try {
+    port.postMessage({ type: MSG.SESSION_ACK, handle: key });
+  } catch (err) {
+    console.warn("[httpuv-sw] session ACK failed", err);
+    clearSessionPort(key);
+  }
+}
+async function deliverWsPushOne(key, msg) {
+  const port = sessionPorts.get(key);
+  if (!port) {
+    queueWsPush(key, msg);
+    requestSessionPortReregister(key);
+    return;
+  }
+  const pushId = nextSessionPushId++;
+  const ackPromise = waitForSessionPushAck(pushId);
+  if (!postWsPushToPort(port, key, msg, pushId)) {
+    pendingSessionAcks.delete(pushId);
+    clearSessionPort(key);
+    queueWsPush(key, msg);
+    requestSessionPortReregister(key);
+    return;
+  }
+  try {
+    await ackPromise;
+  } catch (err) {
+    console.warn("[httpuv-sw] session WS_PUSH_ACK failed; re-queueing frame", err);
+    queueWsPush(key, msg);
+    requestSessionPortReregister(key);
+  }
+}
+function deliverWsPush(handle, msg) {
+  const key = normalizeSessionHandle(handle);
+  httpuvDebugLog("sw-ws-push", {
+    handle: key,
+    wsType: msg.wsType,
+    messageLen: messageBodyLength(msg.message),
+    hasPort: Boolean(sessionPorts.get(key)),
+    queuedBefore: queuedWsPush.get(key)?.length ?? 0
+  });
+  const prev = sessionDeliverChain.get(key) ?? Promise.resolve();
+  const next = prev.then(() => deliverWsPushOne(key, msg)).catch((err) => {
+    console.warn("[httpuv-sw] session deliver chain error", err);
+  });
+  sessionDeliverChain.set(key, next);
+}
+function handleSessionRecv() {
+  return new Response("session recv long-poll is retired; use REGISTER_SESSION MessagePort", {
+    status: 410,
+    headers: { "Content-Type": "text/plain" }
+  });
+}
+function isShinyAppClientUrl(url) {
+  try {
+    const pathname = new URL(url).pathname;
+    return pathname.startsWith(shinyAppPrefix) || pathname.startsWith(SHINY_PREFIX);
+  } catch {
+    return false;
+  }
+}
+function handleHostOutboundMessage(msg) {
+  switch (msg.type) {
+    case MSG.HTTP_RESPONSE: {
+      httpuvDebugLog("sw-response", { uuid: msg.uuid, status: msg.status });
+      const pending = msg.uuid ? pendingHttp.get(msg.uuid) : void 0;
+      if (!pending || !msg.uuid) {
+        httpuvDebugLog("sw-response-orphan", { uuid: msg.uuid });
+        return;
+      }
+      clearTimeout(pending.timer);
+      pendingHttp.delete(msg.uuid);
+      const resp = maybePatchAppDocumentResponse(
+        {
+          status: msg.status ?? 500,
+          headers: msg.headers ?? {},
+          body: msg.body ?? null
+        },
+        pending.url,
+        pending.method,
+        isAppDocumentRequest
+      );
+      maybeCacheAppDocument(resp, pending.url, pending.method);
+      pending.resolve(resp);
+      break;
+    }
+    case MSG.WS_PUSH: {
+      if (!msg.handle) {
+        httpuvDebugLog("sw-ws-push-missing-handle");
+        return;
+      }
+      httpuvDebugLog("sw-ws-push-inbound", {
+        handle: normalizeSessionHandle(msg.handle),
+        wsType: msg.wsType,
+        messageLen: messageBodyLength(msg.message)
+      });
+      deliverWsPush(normalizeSessionHandle(msg.handle), msg);
+      break;
+    }
+    default:
+      httpuvDebugLog("sw-unknown-push", { type: msg.type });
+  }
+}
+async function handleHostPush(event) {
+  try {
+    const msg = await event.request.json();
+    handleHostOutboundMessage(msg);
+    return new Response(null, { status: 204 });
+  } catch (err) {
+    console.error("[httpuv-sw] host push failed", err);
+    return new Response("bad host push payload", { status: 400 });
+  }
+}
+async function handleShinyFetch(event) {
+  const request = event.request;
+  const uuid = crypto.randomUUID();
+  httpuvDebugLog("sw-request", { uuid, method: request.method, url: request.url });
+  const bypassAppCache = request.headers.get(WARMUP_REQUEST_HEADER) === "1";
+  if (request.method === "GET" && isAppDocumentRequest(request.url) && cachedAppDocument && !bypassAppCache) {
+    const cachedPatch = cachedAppDocument.headers?.["x-lucent-app-patch"];
+    if (cachedPatch !== LUCENT_APP_PATCH_VERSION) {
+      httpuvDebugLog("sw-app-cache-stale", {
+        uuid,
+        cachedPatch: cachedPatch ?? null,
+        want: LUCENT_APP_PATCH_VERSION
+      });
+      clearCachedAppDocument();
+    } else {
+      httpuvDebugLog("sw-app-cache-hit", { uuid, url: request.url });
+      const refreshed = maybePatchAppDocumentResponse(
+        clonePendingResponse(cachedAppDocument),
+        request.url,
+        request.method,
+        isAppDocumentRequest
+      );
+      return toFetchResponse(refreshed);
+    }
+  }
+  const staticRes = await tryServeShinyStaticAsset(request);
+  if (staticRes) {
+    return staticRes;
+  }
+  if (!rwasmHost) {
+    void requestComlinkFromHost();
+    try {
+      await waitForRwasmHost();
+    } catch (err) {
+      console.error("[httpuv-sw] R worker not ready for", request.url, err);
+      return new Response("Shiny R worker is not ready", {
+        status: 503,
+        headers: { "Content-Type": "text/plain" }
+      });
+    }
+  }
+  const host = rwasmHost;
+  if (!host) {
+    return new Response("Shiny R worker is not ready", {
+      status: 503,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+  const body = request.method === "GET" || request.method === "HEAD" ? null : await request.arrayBuffer();
+  const responsePromise = waitForHttpResponse(uuid, request.url, request.method);
+  const payload = {
+    uuid,
+    method: request.method,
+    url: request.url,
+    headers: await headersToObject(request),
+    body,
+    clientId: event.clientId
+  };
+  const delivery = host.deliverHttpRequest(body ? comlink_exports.transfer(payload, [body]) : payload).catch((err) => {
+    console.error("[httpuv-sw] R worker request failed", err);
+    throw err;
+  });
+  try {
+    const resp = await responsePromise;
+    await delivery;
+    return toFetchResponse(resp);
+  } catch (err) {
+    const pending = pendingHttp.get(uuid);
+    if (pending) {
+      clearTimeout(pending.timer);
+      pendingHttp.delete(uuid);
+    }
+    console.error("[httpuv-sw]", err);
+    const failed = err instanceof Error && err.message.includes("request failed");
+    return new Response(failed ? "Bad Gateway" : "Gateway Timeout", {
+      status: failed ? 502 : 504,
+      headers: { "Content-Type": "text/plain" }
+    });
+  }
+}
+swSelf.addEventListener("fetch", (event) => {
+  const url = new URL(event.request.url);
+  if (event.request.method === "GET" || event.request.method === "HEAD") {
+    if (vfsPathFromLibRRequest(url.pathname)) {
+      event.respondWith(
+        (async () => {
+          if (!rwasmHost) {
+            void requestComlinkFromHost();
+          }
+          const served = await tryServeLibRAsset(event.request);
+          if (!served) {
+            return new Response("Not Found", { status: 404 });
+          }
+          return served;
+        })()
+      );
+      return;
+    }
+  }
+  if (!pathUnderShinyPrefix(url.pathname)) {
+    return;
+  }
+  if (isHostPushUrl(event.request.url, shinyAppPrefix) || isHostPushUrl(event.request.url, SHINY_PREFIX)) {
+    event.respondWith(handleHostPush(event));
+    return;
+  }
+  const session = parseSessionAction(event.request.url, shinyAppPrefix) ?? parseSessionAction(event.request.url, SHINY_PREFIX);
+  if (session?.action === "recv") {
+    event.respondWith(handleSessionRecv());
+    return;
+  }
+  event.respondWith(handleShinyFetch(event));
+});
+function replyToMessageSource(event, msg) {
+  const source = event.source;
+  if (!source) {
+    httpuvDebugLog("sw-reply-no-source", { type: msg.type });
+    return;
+  }
+  try {
+    source.postMessage(msg);
+  } catch (err) {
+    httpuvDebugLog("sw-reply-failed", { type: msg.type, err: String(err) });
+  }
+}
+swSelf.addEventListener("message", (event) => {
+  const msg = event.data;
+  if (msg === "skipWaiting" || msg?.type === "SKIP_WAITING") {
+    void swSelf.skipWaiting();
+    return;
+  }
+  if (!msg || typeof msg !== "object") {
+    return;
+  }
+  if (msg.type === COMLINK.PORT_HANDOFF && event.ports[0]) {
+    const port = event.ports[0];
+    port.start();
+    httpuvDebugLog("sw-port-handoff");
+    replyToMessageSource(event, { type: COMLINK.PORT_HANDOFF_ACK });
+    rollRwasmHostWaiter();
+    void connectSwToWorker(port);
+    return;
+  }
+  if (msg.type === MSG.REGISTER_SESSION && event.ports[0]) {
+    const handle = normalizeSessionHandle(msg.handle);
+    if (!handle) {
+      httpuvDebugLog("sw-session-register-missing-handle");
+      try {
+        event.ports[0].close();
+      } catch {
+      }
+      return;
+    }
+    const source = event.source;
+    const clientId = source && "id" in source ? String(source.id) : void 0;
+    registerSessionPort(handle, event.ports[0], clientId);
+    return;
+  }
+  if (typeof msg.type !== "string") {
+    return;
+  }
+  switch (msg.type) {
+    case MSG.REGISTER_HOST: {
+      if (typeof msg.shinyPrefix === "string" && msg.shinyPrefix) {
+        shinyAppPrefix = msg.shinyPrefix.endsWith("/") ? msg.shinyPrefix : `${msg.shinyPrefix}/`;
+      }
+      const source = event.source;
+      if (source && "id" in source) {
+        hostClientId = source.id;
+        httpuvDebugLog("sw-host-registered", { hostClientId });
+      }
+      break;
+    }
+    case MSG.HTTP_RESPONSE: {
+      handleHostOutboundMessage(msg);
+      break;
+    }
+    case MSG.WS_PUSH: {
+      handleHostOutboundMessage(msg);
+      break;
+    }
+    case MSG.CLEAR_APP_CACHE: {
+      clearCachedAppDocument();
+      clearShinyResourcePaths();
+      break;
+    }
+    case MSG.REGISTER_RESOURCE_PATHS: {
+      setShinyResourcePaths(msg.paths);
+      break;
+    }
+    case MSG.UPDATE_RESOURCE_PATH: {
+      updateShinyResourcePath(String(msg.prefix ?? ""), msg.dir == null ? "" : String(msg.dir));
+      break;
+    }
+    case MSG.STOP: {
+      clearCachedAppDocument();
+      clearShinyResourcePaths();
+      for (const [uuid, pending] of pendingHttp) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("httpuv stopped"));
+        pendingHttp.delete(uuid);
+      }
+      for (const handle of [...sessionPorts.keys()]) {
+        clearSessionPort(handle);
+      }
+      sessionClientIds.clear();
+      sessionPortReregisterPending.clear();
+      queuedWsPush.clear();
+      hostClientId = null;
+      if (rwasmHost) {
+        void rwasmHost.stop().catch((err) => {
+          console.warn("[httpuv-sw] R worker stop failed", err);
+        });
+      }
+      resetRwasmHostWaiter(new Error("httpuv stopped"));
+      break;
+    }
+  }
+});
+/*! Bundled license information:
+
+comlink/dist/esm/comlink.mjs:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/
+//# sourceMappingURL=httpuv-sw.js.map
+//# sourceMappingURL=httpuv-sw.js.map