lucent-pack 0.1.0__py3-none-any.whl

lucent_pack/static/lucent/dist/runApp.js

@@ -0,0 +1,1056 @@
+// src/config.ts
+var DEFAULT_TRANSPORT_BASE_URL = "/lucent/dist/";
+var DEFAULT_SERVICE_WORKER_URL = "/httpuv-sw.js";
+var DEFAULT_R_RUNTIME_BASE_URL = "/runtime/";
+var DEFAULT_EMPACK_META_URL = "/packages/empack_env_meta.json";
+var DEFAULT_SHINY_BASE_URL = "/";
+var LUCENT_CONFIG_PARAM = "lucentConfig";
+function configOverridesFromUrl() {
+  try {
+    const search = globalThis.location?.search;
+    if (!search) {
+      return {};
+    }
+    const raw = new URLSearchParams(search).get(LUCENT_CONFIG_PARAM);
+    if (!raw) {
+      return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function resolveAgainstLocation(url) {
+  const base = typeof self !== "undefined" && self.location?.href ? self.location.href : "http://localhost/";
+  return new URL(url, base);
+}
+function resolveLucentConfig(overrides = {}) {
+  const fromGlobal = globalThis.__LUCENT__ ?? {};
+  const fromUrl = configOverridesFromUrl();
+  const pick = (key) => overrides[key] ?? fromUrl[key] ?? fromGlobal[key];
+  const empackMetaUrl = pick("empackMetaUrl") ?? DEFAULT_EMPACK_META_URL;
+  const empackPackagesBaseUrl = pick("empackPackagesBaseUrl") ?? new URL(".", resolveAgainstLocation(empackMetaUrl)).href;
+  return {
+    transportBaseUrl: pick("transportBaseUrl") ?? DEFAULT_TRANSPORT_BASE_URL,
+    serviceWorkerUrl: pick("serviceWorkerUrl") ?? DEFAULT_SERVICE_WORKER_URL,
+    rRuntimeBaseUrl: pick("rRuntimeBaseUrl") ?? DEFAULT_R_RUNTIME_BASE_URL,
+    empackMetaUrl,
+    empackPackagesBaseUrl,
+    shinyBaseUrl: pick("shinyBaseUrl") ?? DEFAULT_SHINY_BASE_URL
+  };
+}
+
+// src/debug.ts
+function isLucentDebug() {
+  if (globalThis.__HTTPUV_DEBUG__) {
+    return true;
+  }
+  try {
+    if (typeof localStorage !== "undefined" && localStorage.getItem("shinyForgeDebug") === "1") {
+      return true;
+    }
+    const loc = typeof location !== "undefined" ? location : typeof self !== "undefined" && "location" in self ? self.location : void 0;
+    if (loc?.href) {
+      const params = new URL(loc.href).searchParams;
+      if (params.has("httpuvDebug") || params.get("debug") === "httpuv") {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function lucentInfo(...args) {
+  if (!isLucentDebug()) {
+    return;
+  }
+  console.info(...args);
+}
+function forwardRWorkerLog(level, text) {
+  if (level === "error") {
+    console.error(`[rWasmWorker] ${text}`);
+    return;
+  }
+  console.log(`[rWasmWorker] ${text}`);
+}
+
+// src/rwasm-constants.ts
+var RWASM = {
+  READY: "rwasm_ready",
+  EVAL: "rwasm_eval",
+  EVAL_RESULT: "rwasm_eval_result",
+  STOP_APP: "rwasm_stop_app",
+  REMOUNT_R_HOME: "rwasm_remount_r_home",
+  STOPPED: "rwasm_stopped",
+  COMLINK_PORT: "rwasm_comlink_port",
+  COMLINK_READY: "rwasm_comlink_ready",
+  GET_RESOURCE_PATHS: "rwasm_get_resource_paths",
+  RESOURCE_PATHS: "rwasm_resource_paths",
+  LOG: "rwasm_log",
+  /** Worker → main: empack package download progress. */
+  DOWNLOAD_PROGRESS: "rwasm_download_progress",
+  /** Worker → main: coarse boot phase updates after / around downloads. */
+  BOOT_STATUS: "rwasm_boot_status",
+  ERROR: "rwasm_error",
+  /** Main → worker: run one shiny::serviceOnce tick. */
+  SERVICE_TICK: "rwasm_service_tick",
+  /** Worker → main: result of a SERVICE_TICK (`hadWork` / `nextDelayMs`). */
+  SERVICE_STATUS: "rwasm_service_status",
+  /** Worker → main: schedule an immediate MessageChannel wake. */
+  NEED_SERVICE: "rwasm_need_service",
+  /** Worker → main: delayed wake (`delayMs`) via setTimeout then MessageChannel.
+   * Used when scheduleTask runs outside a SERVICE_TICK; idle delays after a tick
+   * go through SERVICE_STATUS.nextDelayMs instead. */
+  SCHEDULE_DELAY: "rwasm_schedule_delay"
+};
+
+// src/rWasmServiceDriver.ts
+function createServiceDriver(options = {}) {
+  let worker = null;
+  let rafPending = false;
+  let rafId = 0;
+  let tickInFlight = false;
+  let wakeQueued = false;
+  let soonPending = false;
+  let stopped = true;
+  const delayTimers = /* @__PURE__ */ new Set();
+  let delayDeadline = Infinity;
+  const soonChannel = new MessageChannel();
+  soonChannel.port1.onmessage = () => {
+    if (!soonPending) {
+      return;
+    }
+    soonPending = false;
+    if (stopped || !worker) {
+      return;
+    }
+    postTick();
+  };
+  function clearSoon() {
+    soonPending = false;
+  }
+  function clearDelayOnly() {
+    for (const id of delayTimers) {
+      clearTimeout(id);
+    }
+    delayTimers.clear();
+    delayDeadline = Infinity;
+  }
+  function clearDelayTimers() {
+    clearDelayOnly();
+    clearSoon();
+  }
+  function cancelRaf() {
+    if (rafPending && rafId) {
+      cancelAnimationFrame(rafId);
+    }
+    rafPending = false;
+    rafId = 0;
+  }
+  function postTick() {
+    if (!worker || stopped) {
+      return;
+    }
+    if (tickInFlight) {
+      wakeQueued = true;
+      return;
+    }
+    tickInFlight = true;
+    wakeQueued = false;
+    worker.postMessage({ type: RWASM.SERVICE_TICK });
+  }
+  function onFrame() {
+    rafPending = false;
+    rafId = 0;
+    if (stopped || !worker) {
+      return;
+    }
+    postTick();
+  }
+  function wake() {
+    if (stopped || !worker) {
+      return;
+    }
+    if (document.visibilityState !== "visible") {
+      return;
+    }
+    if (tickInFlight) {
+      wakeQueued = true;
+      return;
+    }
+    if (rafPending) {
+      wakeQueued = true;
+      return;
+    }
+    rafPending = true;
+    rafId = requestAnimationFrame(onFrame);
+  }
+  function wakeSoon() {
+    if (stopped || !worker) {
+      return;
+    }
+    if (tickInFlight) {
+      wakeQueued = true;
+      return;
+    }
+    if (soonPending) {
+      wakeQueued = true;
+      return;
+    }
+    soonPending = true;
+    soonChannel.port2.postMessage(0);
+  }
+  function scheduleFollowUp() {
+    wakeSoon();
+    wake();
+  }
+  function scheduleDelay(delayMs) {
+    if (stopped || !worker) {
+      return;
+    }
+    const ms = Math.max(0, Number(delayMs) || 0);
+    if (ms <= 0) {
+      scheduleFollowUp();
+      return;
+    }
+    const deadline = performance.now() + ms;
+    if (deadline >= delayDeadline) {
+      return;
+    }
+    clearDelayOnly();
+    delayDeadline = deadline;
+    const id = setTimeout(() => {
+      delayTimers.delete(id);
+      delayDeadline = Infinity;
+      scheduleFollowUp();
+    }, ms);
+    delayTimers.add(id);
+  }
+  function onWorkerMessage(event) {
+    const data = event.data;
+    if (!data || typeof data.type !== "string") {
+      return;
+    }
+    if (data.type === RWASM.SERVICE_STATUS) {
+      tickInFlight = false;
+      const status = data;
+      const hadWork = Boolean(status.hadWork);
+      const nextDelayMs = Number(status.nextDelayMs);
+      if (stopped) {
+        return;
+      }
+      if (hadWork || wakeQueued) {
+        if (hadWork) {
+          options.onHadWork?.();
+        }
+        wakeQueued = false;
+        scheduleFollowUp();
+        return;
+      }
+      if (Number.isFinite(nextDelayMs) && nextDelayMs >= 0) {
+        scheduleDelay(nextDelayMs);
+      } else {
+        clearDelayOnly();
+      }
+      return;
+    }
+    if (data.type === RWASM.NEED_SERVICE) {
+      scheduleFollowUp();
+      return;
+    }
+    if (data.type === RWASM.SCHEDULE_DELAY) {
+      scheduleDelay(Number(data.delayMs) || 0);
+    }
+  }
+  function onVisibilityChange() {
+    if (stopped) {
+      return;
+    }
+    if (document.visibilityState === "visible") {
+      scheduleFollowUp();
+    }
+  }
+  function attach(next) {
+    if (worker === next && !stopped) {
+      return;
+    }
+    stop();
+    worker = next;
+    stopped = false;
+    worker.addEventListener("message", onWorkerMessage);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+  }
+  function stop() {
+    stopped = true;
+    tickInFlight = false;
+    wakeQueued = false;
+    cancelRaf();
+    clearDelayTimers();
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+    if (worker) {
+      worker.removeEventListener("message", onWorkerMessage);
+      worker = null;
+    }
+  }
+  return { wake, scheduleDelay, attach, stop };
+}
+
+// src/transport.ts
+var cached = null;
+function transportUrl(baseUrl) {
+  const base = new URL(baseUrl, self.location.href);
+  return new URL("httpuv-web.js", base).href;
+}
+function loadTransport(baseUrl) {
+  if (!cached) {
+    const url = transportUrl(baseUrl);
+    cached = import(
+      /* @vite-ignore */
+      /* webpackIgnore: true */
+      url
+    );
+  }
+  return cached;
+}
+
+// src/wiring.ts
+var HANDOFF_ATTEMPTS = 3;
+var HANDOFF_ACK_TIMEOUT_MS = 5e3;
+var COMLINK_READY_TIMEOUT_MS = 3e4;
+async function connectHttpuvComlink(rWorker2, portHandoffType, options = {}) {
+  const {
+    ackType,
+    attempts = HANDOFF_ATTEMPTS,
+    ackTimeoutMs = HANDOFF_ACK_TIMEOUT_MS,
+    readyTimeoutMs = COMLINK_READY_TIMEOUT_MS
+  } = options;
+  const ready = watchWorkerComlinkReady(rWorker2);
+  const deadline = Date.now() + readyTimeoutMs;
+  const maxAttempts = ackType ? Math.max(1, attempts) : 1;
+  let connected = false;
+  let acked = false;
+  try {
+    for (let attempt = 1; attempt <= maxAttempts && !connected && !acked; attempt += 1) {
+      const ack = ackType ? watchServiceWorkerMessage(ackType) : null;
+      try {
+        postComlinkPorts(rWorker2, portHandoffType);
+        const outcome = await raceHandshake(ready.promise, ack?.promise, ackTimeoutMs);
+        connected = outcome === "ready";
+        acked = outcome === "acked";
+        if (outcome === "pending") {
+          lucentInfo(
+            `[lucent] service worker did not confirm the Comlink port handoff (attempt ${attempt}/${maxAttempts})`
+          );
+        }
+      } finally {
+        ack?.cancel();
+      }
+    }
+    if (!connected) {
+      await waitFor(
+        ready.promise,
+        Math.max(0, deadline - Date.now()),
+        () => comlinkTimeoutError(Boolean(ackType), acked)
+      );
+    }
+    lucentInfo("[lucent] service worker <-> R worker connected (unified port)");
+  } finally {
+    ready.cancel();
+  }
+}
+function postComlinkPorts(rWorker2, portHandoffType) {
+  const controller = navigator.serviceWorker.controller;
+  if (!controller) {
+    throw new Error("Service worker controller is not available for Comlink setup");
+  }
+  const channel = new MessageChannel();
+  controller.postMessage({ type: portHandoffType }, [channel.port1]);
+  rWorker2.postMessage({ type: RWASM.COMLINK_PORT }, [channel.port2]);
+}
+function comlinkTimeoutError(canAck, acked) {
+  if (!canAck) {
+    return new Error("Comlink setup timed out");
+  }
+  if (acked) {
+    return new Error(
+      "Comlink setup timed out: the service worker took the port but the R worker never completed setup"
+    );
+  }
+  return new Error(
+    "Comlink setup timed out: the service worker never acknowledged the port handoff"
+  );
+}
+async function raceHandshake(ready, ack, timeoutMs) {
+  const timer = timeoutWatcher(timeoutMs);
+  try {
+    return await Promise.race([
+      ready.then(() => "ready"),
+      ...ack ? [ack.then(() => "acked")] : [],
+      timer.promise.then(() => "pending")
+    ]);
+  } finally {
+    timer.cancel();
+  }
+}
+async function waitFor(promise, timeoutMs, onTimeout) {
+  const timer = timeoutWatcher(timeoutMs);
+  try {
+    const timedOut = await Promise.race([
+      promise.then(() => false),
+      timer.promise.then(() => true)
+    ]);
+    if (timedOut) {
+      throw onTimeout();
+    }
+  } finally {
+    timer.cancel();
+  }
+}
+function timeoutWatcher(ms) {
+  let timer;
+  const promise = new Promise((resolve) => {
+    timer = setTimeout(resolve, ms);
+  });
+  return { promise, cancel: () => clearTimeout(timer) };
+}
+function watchWorkerComlinkReady(rWorker2) {
+  let cleanup = () => {
+  };
+  const promise = new Promise((resolve, reject) => {
+    const onMessage = (event) => {
+      if (event.data?.type === RWASM.COMLINK_READY) {
+        cleanup();
+        resolve();
+      }
+      if (event.data?.type === RWASM.ERROR) {
+        cleanup();
+        reject(new Error(event.data.message ?? "R worker Comlink setup failed"));
+      }
+    };
+    cleanup = () => rWorker2.removeEventListener("message", onMessage);
+    rWorker2.addEventListener("message", onMessage);
+  });
+  return { promise, cancel: () => cleanup() };
+}
+function watchServiceWorkerMessage(type) {
+  let cleanup = () => {
+  };
+  const promise = new Promise((resolve) => {
+    const onMessage = (event) => {
+      if (event.data?.type === type) {
+        cleanup();
+        resolve();
+      }
+    };
+    cleanup = () => navigator.serviceWorker.removeEventListener("message", onMessage);
+    navigator.serviceWorker.addEventListener("message", onMessage);
+  });
+  return { promise, cancel: () => cleanup() };
+}
+
+// src/runApp.ts
+var RUN_WEB_APP_R = `
+local({
+  loadNamespace("shiny")
+  shiny::startApp(appDir = "webApp", port = 3838L, host = "127.0.0.1", launch.browser = FALSE, quiet = TRUE)
+})
+`;
+var config = resolveLucentConfig();
+var transport = null;
+var rWorker = null;
+var rWorkerPromise = null;
+var comlinkConnected = false;
+var comlinkPromise = null;
+var comlinkHandshakeInFlight = false;
+var swRegistrationPromise = null;
+var httpuvReadyPromise = null;
+var evalSeq = 0;
+var serviceDriver = null;
+var HTTPUV_SW_RELOAD_KEY = "httpuv-sw-reload";
+function requireTransport() {
+  if (!transport) {
+    throw new Error("[lucent] transport not loaded yet");
+  }
+  return transport;
+}
+function shinyBaseUrl() {
+  return new URL(config.shinyBaseUrl, self.location.href).href;
+}
+function shinyPrefix() {
+  return requireTransport().resolveShinyPrefix(shinyBaseUrl());
+}
+function appUrl(subpath = "") {
+  return requireTransport().shinyAppUrl(subpath, shinyBaseUrl());
+}
+function serviceWorkerScriptUrl() {
+  const url = new URL(config.serviceWorkerUrl, self.location.href);
+  url.searchParams.set("shinyPrefix", shinyPrefix());
+  return url;
+}
+function serviceWorkerScope() {
+  return new URL("./", serviceWorkerScriptUrl()).pathname;
+}
+function announceHostToServiceWorker() {
+  const t = requireTransport();
+  const prefix = shinyPrefix();
+  const msg = {
+    type: t.MSG.REGISTER_HOST,
+    shinyPrefix: prefix
+  };
+  const controller = navigator.serviceWorker.controller;
+  if (controller) {
+    controller.postMessage(msg);
+    lucentInfo("[httpuv] Announced host to service worker");
+    return true;
+  }
+  return false;
+}
+async function waitForServiceWorkerController(timeoutMs = 3e3) {
+  if (navigator.serviceWorker.controller) {
+    return navigator.serviceWorker.controller;
+  }
+  await navigator.serviceWorker.ready;
+  if (navigator.serviceWorker.controller) {
+    return navigator.serviceWorker.controller;
+  }
+  return new Promise((resolve, reject) => {
+    const deadline = setTimeout(() => {
+      navigator.serviceWorker.removeEventListener("controllerchange", onController);
+      reject(new Error("timeout"));
+    }, timeoutMs);
+    const onController = () => {
+      if (navigator.serviceWorker.controller) {
+        clearTimeout(deadline);
+        navigator.serviceWorker.removeEventListener("controllerchange", onController);
+        resolve(navigator.serviceWorker.controller);
+      }
+    };
+    navigator.serviceWorker.addEventListener("controllerchange", onController);
+    onController();
+  });
+}
+async function waitForServiceWorkerInstall(reg, timeoutMs = 15e3) {
+  const worker = reg.waiting ?? reg.installing ?? reg.active;
+  if (!worker) {
+    await navigator.serviceWorker.ready;
+    return;
+  }
+  if (worker.state === "activated" || worker.state === "installed") {
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const onStateChange = () => {
+      if (worker.state === "activated" || worker.state === "installed" || worker.state === "redundant") {
+        cleanup();
+        resolve();
+      }
+    };
+    const deadline = setTimeout(() => {
+      cleanup();
+      if (worker.state === "installed") {
+        resolve();
+        return;
+      }
+      reject(new Error(`Service worker activation timed out (state: ${worker.state})`));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(deadline);
+      worker.removeEventListener("statechange", onStateChange);
+    };
+    worker.addEventListener("statechange", onStateChange);
+    onStateChange();
+  });
+}
+function serviceWorkerScriptPath() {
+  return serviceWorkerScriptUrl().href.split("?")[0];
+}
+function controllerMatchesExpectedScript() {
+  const expected = serviceWorkerScriptPath();
+  const current = navigator.serviceWorker.controller?.scriptURL.split("?")[0];
+  return current === expected;
+}
+async function cleanupStaleHttpuvServiceWorkers() {
+  const expected = serviceWorkerScriptPath();
+  for (const reg of await navigator.serviceWorker.getRegistrations()) {
+    const scriptUrls = [reg.active, reg.waiting, reg.installing].filter((worker) => worker != null).map((worker) => worker.scriptURL.split("?")[0]);
+    const isHttpuv = scriptUrls.some((url) => url.endsWith("/httpuv-sw.js"));
+    if (!isHttpuv) {
+      continue;
+    }
+    if (!scriptUrls.includes(expected)) {
+      lucentInfo("[httpuv] Unregistering stale service worker", scriptUrls);
+      await reg.unregister();
+    }
+  }
+}
+async function registerHttpuvServiceWorker() {
+  if (!("serviceWorker" in navigator)) {
+    console.warn("[httpuv] Service workers are not supported in this browser");
+    return null;
+  }
+  try {
+    await cleanupStaleHttpuvServiceWorkers();
+    const reg = await navigator.serviceWorker.register(serviceWorkerScriptUrl(), {
+      scope: serviceWorkerScope(),
+      updateViaCache: "none"
+    });
+    await waitForServiceWorkerInstall(reg);
+    if (reg.waiting) {
+      reg.waiting.postMessage({ type: "SKIP_WAITING" });
+      await waitForServiceWorkerInstall(reg, 5e3).catch(() => void 0);
+    }
+    if (!navigator.serviceWorker.controller || !controllerMatchesExpectedScript()) {
+      const reloaded = sessionStorage.getItem(HTTPUV_SW_RELOAD_KEY);
+      if (!reloaded) {
+        sessionStorage.setItem(HTTPUV_SW_RELOAD_KEY, "1");
+        lucentInfo("[httpuv] Service worker installed \u2014 reloading once to activate");
+        window.location.reload();
+        await new Promise(() => {
+        });
+      }
+      console.warn(
+        "[httpuv] Page still not controlled by the expected worker; check Application \u2192 Service Workers for httpuv-sw.js errors"
+      );
+    } else {
+      sessionStorage.removeItem(HTTPUV_SW_RELOAD_KEY);
+    }
+    await waitForServiceWorkerController().catch(() => void 0);
+    announceHostToServiceWorker();
+    lucentInfo("[httpuv] Service worker registered", {
+      scope: reg.scope,
+      shinyPrefix: shinyPrefix(),
+      controller: Boolean(navigator.serviceWorker.controller)
+    });
+    return reg;
+  } catch (err) {
+    console.error("[httpuv] Service worker registration failed:", err);
+    throw err;
+  }
+}
+function ensureHttpuvServiceWorker() {
+  if (!swRegistrationPromise) {
+    swRegistrationPromise = registerHttpuvServiceWorker();
+  }
+  return swRegistrationPromise;
+}
+function postToRWorker(worker, msg, transfer = []) {
+  const id = msg.id ?? `m${++evalSeq}`;
+  const payload = { ...msg, id };
+  return new Promise((resolve, reject) => {
+    const onMessage = (event) => {
+      const data = event.data;
+      if (!data || data.id !== id) {
+        if (data?.type === RWASM.ERROR && !msg.id) {
+          worker.removeEventListener("message", onMessage);
+          reject(new Error(data.message ?? "R worker failed"));
+        }
+        return;
+      }
+      if (data.type === RWASM.EVAL_RESULT || data.type === RWASM.STOPPED || data.type === RWASM.RESOURCE_PATHS) {
+        worker.removeEventListener("message", onMessage);
+        if (data.type === RWASM.STOPPED || data.type === RWASM.RESOURCE_PATHS || data.ok) {
+          resolve(data);
+        } else {
+          reject(new Error(data.error ?? "eval failed"));
+        }
+      }
+    };
+    worker.addEventListener("message", onMessage);
+    worker.postMessage(payload, transfer);
+  });
+}
+function workerConfigParam() {
+  const base = self.location.href;
+  const abs = (u) => u == null ? void 0 : new URL(u, base).href;
+  const payload = {
+    transportBaseUrl: abs(config.transportBaseUrl),
+    serviceWorkerUrl: abs(config.serviceWorkerUrl),
+    rRuntimeBaseUrl: abs(config.rRuntimeBaseUrl),
+    empackMetaUrl: abs(config.empackMetaUrl),
+    empackPackagesBaseUrl: abs(config.empackPackagesBaseUrl),
+    shinyBaseUrl: abs(config.shinyBaseUrl)
+  };
+  return JSON.stringify(payload);
+}
+function dispatchLucentEvent(name, detail) {
+  window.dispatchEvent(new CustomEvent(name, { detail }));
+}
+function reportBootStatus(phase, message, percent) {
+  dispatchLucentEvent("lucent:boot-status", { phase, message, percent });
+}
+function installWorkerUiEvents(worker) {
+  worker.addEventListener("message", (event) => {
+    const data = event.data;
+    if (data?.type === RWASM.LOG) {
+      forwardRWorkerLog(data.level === "error" ? "error" : "log", data.text ?? "");
+      return;
+    }
+    if (data?.type === RWASM.DOWNLOAD_PROGRESS) {
+      dispatchLucentEvent("lucent:download-progress", {
+        percent: data.percent ?? null,
+        downloadedBytes: data.downloadedBytes ?? 0,
+        totalBytes: data.totalBytes ?? 0
+      });
+      return;
+    }
+    if (data?.type === RWASM.BOOT_STATUS) {
+      dispatchLucentEvent("lucent:boot-status", {
+        phase: data.phase ?? "",
+        message: data.message ?? "",
+        percent: data.percent ?? null
+      });
+    }
+  });
+}
+function createRWorker() {
+  const workerUrl = new URL("./rWasmWorker.js", import.meta.url);
+  workerUrl.searchParams.set(LUCENT_CONFIG_PARAM, workerConfigParam());
+  if (requireTransport().isHttpuvDebug()) {
+    workerUrl.searchParams.set("httpuvDebug", "1");
+  }
+  const worker = new Worker(workerUrl, { type: "module" });
+  installWorkerUiEvents(worker);
+  return new Promise((resolve, reject) => {
+    const onBoot = (event) => {
+      const data = event.data;
+      if (data?.type === RWASM.LOG || data?.type === RWASM.DOWNLOAD_PROGRESS || data?.type === RWASM.BOOT_STATUS) {
+        return;
+      }
+      if (data?.type === RWASM.READY) {
+        worker.removeEventListener("message", onBoot);
+        lucentInfo("[runApp] R.wasm worker ready");
+        resolve(worker);
+        return;
+      }
+      if (data?.type === RWASM.ERROR) {
+        worker.removeEventListener("message", onBoot);
+        reject(new Error(data.message ?? "R worker bootstrap failed"));
+      }
+    };
+    worker.addEventListener("message", onBoot);
+    worker.addEventListener("error", (event) => {
+      worker.removeEventListener("message", onBoot);
+      const detail = [event.message, event.filename, event.lineno].filter(Boolean).join(" ");
+      reject(new Error(detail ? `R worker failed to load: ${detail}` : "R worker failed to load"));
+    });
+  });
+}
+async function ensureRWorker() {
+  if (rWorker) {
+    return rWorker;
+  }
+  if (!rWorkerPromise) {
+    rWorkerPromise = createRWorker().then((worker) => {
+      rWorker = worker;
+      if (!serviceDriver) {
+        serviceDriver = createServiceDriver({
+          onHadWork: scheduleDebouncedResourcePathSync
+        });
+      }
+      serviceDriver.attach(worker);
+      return worker;
+    });
+  }
+  return rWorkerPromise;
+}
+function ensureComlinkConnected() {
+  if (comlinkPromise && (comlinkConnected || comlinkHandshakeInFlight)) {
+    return comlinkPromise;
+  }
+  comlinkHandshakeInFlight = true;
+  const handshake = (async () => {
+    lucentInfo("[runApp] Waiting for R worker and service worker\u2026");
+    const [worker] = await Promise.all([ensureRWorker(), ensureHttpuvServiceWorker()]);
+    if (!navigator.serviceWorker.controller || !controllerMatchesExpectedScript()) {
+      throw new Error("Service worker controller is not available");
+    }
+    lucentInfo("[runApp] Connecting Comlink\u2026");
+    const { COMLINK } = requireTransport();
+    await connectHttpuvComlink(worker, COMLINK.PORT_HANDOFF, {
+      ackType: COMLINK.PORT_HANDOFF_ACK
+    });
+    comlinkConnected = true;
+  })();
+  const clearInFlight = () => {
+    comlinkHandshakeInFlight = false;
+  };
+  handshake.then(clearInFlight, clearInFlight);
+  comlinkPromise = handshake;
+  return handshake;
+}
+function invalidateComlink() {
+  comlinkConnected = false;
+  httpuvReadyPromise = null;
+  if (!comlinkHandshakeInFlight) {
+    comlinkPromise = null;
+  }
+}
+function reconnectComlinkAfterServiceWorkerUpdate() {
+  invalidateComlink();
+  announceHostToServiceWorker();
+  void ensureComlinkConnected().catch((err) => {
+    console.warn("[httpuv] Comlink reconnect after service worker update failed:", err);
+  });
+}
+async function ensureHttpuvReady() {
+  const t = requireTransport();
+  t.setShinyPrefix(shinyPrefix());
+  if (comlinkConnected && comlinkPromise) {
+    return comlinkPromise;
+  }
+  httpuvReadyPromise = ensureComlinkConnected();
+  return httpuvReadyPromise;
+}
+function stopRunningApp() {
+  navigator.serviceWorker.controller?.postMessage({ type: requireTransport().MSG.STOP });
+  serviceDriver?.stop();
+  if (rWorker) {
+    rWorker.postMessage({ type: RWASM.STOP_APP });
+  }
+  lucentInfo("[runApp] App stopped");
+}
+function loadViewerFrame() {
+  const frame = document.getElementById("app-frame");
+  const url = appUrl();
+  if (frame) {
+    frame.src = url;
+  }
+  lucentInfo("[runApp] Viewer iframe \u2192", url);
+}
+function clearAppDocumentCache() {
+  lastResourcePaths = {};
+  navigator.serviceWorker.controller?.postMessage({
+    type: requireTransport().MSG.CLEAR_APP_CACHE
+  });
+}
+var RESOURCE_PATH_SYNC_DEBOUNCE_MS = 100;
+var resourcePathSyncTimer = null;
+var lastResourcePaths = {};
+var resourcePathSyncInFlight = false;
+function scheduleDebouncedResourcePathSync() {
+  if (resourcePathSyncTimer) {
+    clearTimeout(resourcePathSyncTimer);
+  }
+  resourcePathSyncTimer = setTimeout(() => {
+    resourcePathSyncTimer = null;
+    if (rWorker) {
+      void syncResourcePathsIncremental(rWorker);
+    }
+  }, RESOURCE_PATH_SYNC_DEBOUNCE_MS);
+}
+function rememberResourcePaths(paths) {
+  lastResourcePaths = { ...paths };
+}
+async function syncResourcePathsToServiceWorker(worker) {
+  const controller = navigator.serviceWorker.controller;
+  if (!controller) {
+    return;
+  }
+  try {
+    const data = await postToRWorker(worker, { type: RWASM.GET_RESOURCE_PATHS });
+    const paths = data.paths ?? {};
+    rememberResourcePaths(paths);
+    controller.postMessage({ type: requireTransport().MSG.REGISTER_RESOURCE_PATHS, paths });
+    if (Object.keys(paths).length > 0) {
+      lucentInfo("[runApp] synced", Object.keys(paths).length, "resource path(s) to SW");
+    }
+  } catch (err) {
+    console.warn("[runApp] resource path sync failed; SW will fall through to R", err);
+  }
+}
+async function syncResourcePathsIncremental(worker) {
+  if (resourcePathSyncInFlight) {
+    scheduleDebouncedResourcePathSync();
+    return;
+  }
+  const controller = navigator.serviceWorker.controller;
+  if (!controller) {
+    return;
+  }
+  resourcePathSyncInFlight = true;
+  try {
+    const data = await postToRWorker(worker, { type: RWASM.GET_RESOURCE_PATHS });
+    const paths = data.paths ?? {};
+    const updateType = requireTransport().MSG.UPDATE_RESOURCE_PATH;
+    let changed = 0;
+    for (const prefix of Object.keys(paths)) {
+      if (lastResourcePaths[prefix] !== paths[prefix]) {
+        controller.postMessage({ type: updateType, prefix, dir: paths[prefix] });
+        changed += 1;
+      }
+    }
+    for (const prefix of Object.keys(lastResourcePaths)) {
+      if (!(prefix in paths)) {
+        controller.postMessage({ type: updateType, prefix, dir: "" });
+        changed += 1;
+      }
+    }
+    rememberResourcePaths(paths);
+    if (changed > 0) {
+      lucentInfo("[runApp] updated", changed, "resource path(s) on SW");
+    }
+  } catch (err) {
+    console.warn("[runApp] incremental resource path sync failed", err);
+  } finally {
+    resourcePathSyncInFlight = false;
+  }
+}
+async function waitForShinyHttpReady(worker) {
+  const t = requireTransport();
+  const url = appUrl();
+  reportBootStatus("warmup", "Warming up Shiny\u2026", 92);
+  lucentInfo("[runApp] Warming up Shiny (may take a minute on first load)\u2026", url);
+  const res = await fetch(url, {
+    cache: "no-store",
+    headers: { [t.WARMUP_REQUEST_HEADER]: "1" },
+    signal: AbortSignal.timeout(t.REQUEST_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    throw new Error(`Shiny warmup GET ${url} failed: HTTP ${res.status}`);
+  }
+  lucentInfo("[runApp] Shiny warmup OK (HTTP", res.status + ")");
+  await syncResourcePathsToServiceWorker(worker);
+}
+async function runApp() {
+  const worker = await ensureRWorker();
+  clearAppDocumentCache();
+  await postToRWorker(worker, { type: RWASM.STOP_APP });
+  const forceRemount = new URLSearchParams(self.location.search).get("remountRHome") === "1";
+  await postToRWorker(worker, { type: RWASM.REMOUNT_R_HOME, force: forceRemount });
+  lucentInfo("[runApp] worker eval", RUN_WEB_APP_R);
+  reportBootStatus("start-app", "Starting Shiny\u2026", 85);
+  await postToRWorker(worker, {
+    type: RWASM.EVAL,
+    code: RUN_WEB_APP_R
+  });
+  serviceDriver?.attach(worker);
+  serviceDriver?.wake();
+  return 0;
+}
+async function startShinyApp() {
+  await ensureHttpuvReady();
+  const worker = await ensureRWorker();
+  await runApp();
+  invalidateComlink();
+  await ensureHttpuvReady();
+  await waitForShinyHttpReady(worker);
+  loadViewerFrame();
+  dispatchLucentEvent("lucent:ready");
+}
+function installHostServiceWorkerListeners() {
+  navigator.serviceWorker.addEventListener("controllerchange", () => {
+    reconnectComlinkAfterServiceWorkerUpdate();
+  });
+  navigator.serviceWorker.addEventListener("message", (event) => {
+    if (event.data?.type === requireTransport().MSG.REQUEST_COMLINK) {
+      reconnectComlinkAfterServiceWorkerUpdate();
+    }
+  });
+  const reassertHost = () => {
+    announceHostToServiceWorker();
+    if (!comlinkConnected) {
+      reconnectComlinkAfterServiceWorkerUpdate();
+    }
+  };
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "visible") {
+      reassertHost();
+    }
+  });
+  window.addEventListener("pageshow", reassertHost);
+  window.addEventListener("focus", () => {
+    announceHostToServiceWorker();
+  });
+}
+function installGlobalHelpers() {
+  const lucent = {
+    shinyUrl: (subpath = "") => appUrl(subpath),
+    ensureHttpuvReady,
+    stopRunningApp,
+    enableHttpuvDebug: () => requireTransport().enableHttpuvDebug(),
+    /** Quick check that the worker responds. */
+    ping: () => lucent.evalR("1+1"),
+    async evalR(code) {
+      const worker = await ensureRWorker();
+      await postToRWorker(worker, {
+        type: RWASM.EVAL,
+        code
+      });
+    },
+    startShinyApp: () => startShinyApp(),
+    async testVirtualSocket(message = '{"method":"ping"}') {
+      await ensureHttpuvReady();
+      const controller = navigator.serviceWorker.controller;
+      if (!controller) {
+        console.warn(
+          "[lucent] No service worker controller \u2014 fetch may not be intercepted; unregister old workers and hard-refresh"
+        );
+        throw new Error("no service worker controller");
+      }
+      const openUrl = new URL("__session__/open", appUrl());
+      lucentInfo("[lucent] testVirtualSocket: open", openUrl.href);
+      const openRes = await fetch(openUrl, { method: "POST" });
+      if (!openRes.ok) {
+        throw new Error(`session open failed: HTTP ${openRes.status} ${await openRes.text()}`);
+      }
+      const { handle } = await openRes.json();
+      lucentInfo("[lucent] testVirtualSocket: handle", handle);
+      const channel = new MessageChannel();
+      const ack = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("session ACK timed out")), 5e3);
+        channel.port1.onmessage = (event) => {
+          if (event.data?.type === requireTransport().MSG.SESSION_ACK) {
+            clearTimeout(timer);
+            resolve();
+          }
+        };
+      });
+      controller.postMessage(
+        { type: requireTransport().MSG.REGISTER_SESSION, handle },
+        [channel.port2]
+      );
+      await ack;
+      lucentInfo("[lucent] testVirtualSocket: session port registered");
+      const sendUrl = new URL(`__session__/send?handle=${encodeURIComponent(handle)}`, appUrl());
+      const sendRes = await fetch(sendUrl, {
+        method: "POST",
+        headers: { "Content-Type": "text/plain" },
+        body: message
+      });
+      if (!sendRes.ok && sendRes.status !== 204) {
+        throw new Error(`session send failed: HTTP ${sendRes.status}`);
+      }
+      channel.port1.close();
+      const result = { handle, registered: true, sendStatus: sendRes.status };
+      lucentInfo("[lucent] testVirtualSocket: result", result);
+      return result;
+    }
+  };
+  globalThis.__lucent = lucent;
+}
+async function main() {
+  transport = await loadTransport(config.transportBaseUrl);
+  transport.setShinyPrefix(shinyPrefix());
+  installHostServiceWorkerListeners();
+  installGlobalHelpers();
+  if (isLucentDebug()) {
+    lucentInfo("[runApp] httpuv debug tracing enabled (?httpuvDebug=1)");
+  }
+  void ensureHttpuvServiceWorker().catch((err) => {
+    console.error("[httpuv] Service worker setup failed:", err);
+  });
+  await startShinyApp();
+}
+void main().catch((err) => {
+  console.error("[runApp] Failed to start:", err);
+  dispatchLucentEvent("lucent:error", {
+    message: err instanceof Error ? err.message : String(err)
+  });
+});
+
+export { ensureHttpuvReady, runApp };
+//# sourceMappingURL=runApp.js.map
+//# sourceMappingURL=runApp.js.map