lucent-pack 0.1.0__py3-none-any.whl

lucent_pack/static/lucent/dist/rWasmWorker.js

@@ -0,0 +1,1662 @@
+// node_modules/comlink/dist/esm/comlink.mjs
+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 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/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);
+}
+
+// src/rwasm-constants.ts
+var WASM_R_HOME = "/lib/R";
+var WEB_APP_DIR = "/webApp";
+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/rWasmBootstrap.ts
+var evalRPostFlush = null;
+function setEvalRPostFlush(fn) {
+  evalRPostFlush = fn;
+}
+function asDirectoryUrl(url) {
+  const resolved = new URL(url, self.location.href);
+  if (!resolved.pathname.endsWith("/")) {
+    resolved.pathname += "/";
+  }
+  return resolved;
+}
+function createRuntimeAssetUrls(runtimeBaseUrl) {
+  const base = asDirectoryUrl(runtimeBaseUrl);
+  return {
+    glue: new URL("bin/Rmain.js", base),
+    wasm: new URL("bin/Rmain.wasm", base),
+    /** Host mirror of `$PREFIX/lib/R/lib` for MAIN_MODULE dynlink before VFS populate. */
+    rLib: new URL("lib/R/lib/", base)
+  };
+}
+var vfsBlobUrls = /* @__PURE__ */ new Map();
+function clearVfsBlobUrlCache() {
+  for (const url of vfsBlobUrls.values()) {
+    URL.revokeObjectURL(url);
+  }
+  vfsBlobUrls.clear();
+}
+function vfsFileToBlobUrl(module, vfsPath) {
+  const cached2 = vfsBlobUrls.get(vfsPath);
+  if (cached2) {
+    return cached2;
+  }
+  const data = module.FS.readFile(vfsPath, { encoding: "binary" });
+  const copy = new Uint8Array(data.byteLength);
+  copy.set(data);
+  const url = URL.createObjectURL(new Blob([copy.buffer], { type: "application/wasm" }));
+  vfsBlobUrls.set(vfsPath, url);
+  return url;
+}
+function vfsExists(module, path) {
+  try {
+    return module.FS.analyzePath(path).exists;
+  } catch {
+    return false;
+  }
+}
+function resolveSideModuleVfsPath(module, file) {
+  const fileBase = file.split("/").pop() ?? file;
+  const candidates = [];
+  if (file.startsWith("/")) {
+    candidates.push(file);
+  }
+  const pkgMatch = file.match(/(?:^|\/)library\/([^/]+)\/libs\/([^/]+)$/);
+  if (pkgMatch) {
+    candidates.push(`${WASM_R_HOME}/library/${pkgMatch[1]}/libs/${pkgMatch[2]}`);
+  }
+  candidates.push(`${WASM_R_HOME}/lib/${fileBase}`);
+  candidates.push(`/lib/${fileBase}`);
+  if (!file.startsWith("/")) {
+    candidates.push(`/${file}`);
+    candidates.push(`${WASM_R_HOME}/${file}`);
+  }
+  for (const path of candidates) {
+    if (vfsExists(module, path)) {
+      return path;
+    }
+  }
+  return null;
+}
+function createFsBackedLocateFile(moduleRef, runtimeBaseUrl) {
+  const { wasm, rLib } = createRuntimeAssetUrls(runtimeBaseUrl);
+  return function locateFile(file) {
+    const fileBase = file.split("/").pop() ?? file;
+    if (fileBase.endsWith(".wasm")) {
+      return wasm.href;
+    }
+    const module = moduleRef.current;
+    if (module?.FS) {
+      const vfsPath = resolveSideModuleVfsPath(module, file);
+      if (vfsPath) {
+        return vfsFileToBlobUrl(module, vfsPath);
+      }
+    }
+    return new URL(fileBase, rLib).href;
+  };
+}
+function mountRHomeLibToSlashLib(module) {
+  const libDir = `${WASM_R_HOME}/lib`;
+  if (!vfsExists(module, libDir)) {
+    lucentInfo("[rWasm] No", libDir, "to mirror into /lib");
+    return;
+  }
+  module.FS.mkdirTree("/lib");
+  let mirrored = 0;
+  for (const name of module.FS.readdir(libDir)) {
+    if (name === "." || name === ".." || !name.endsWith(".so")) {
+      continue;
+    }
+    const src = `${libDir}/${name}`;
+    const data = module.FS.readFile(src, { encoding: "binary" });
+    module.FS.writeFile(`/lib/${name}`, data);
+    mirrored += 1;
+  }
+  lucentInfo("[rWasm] Mirrored", mirrored, "*.so from", libDir, "\u2192 /lib");
+}
+function verifyMountedTree(module) {
+  const methodsSo = `${WASM_R_HOME}/library/methods/libs/methods.so`;
+  if (!vfsExists(module, methodsSo)) {
+    throw new Error(`Mounted FS is missing ${methodsSo}`);
+  }
+  const data = module.FS.readFile(methodsSo, { encoding: "binary" });
+  if (!(data[0] === 0 && data[1] === 97 && data[2] === 115 && data[3] === 109)) {
+    throw new Error(`${methodsSo} is not a wasm module (bad magic bytes)`);
+  }
+  if (!vfsExists(module, WEB_APP_DIR)) {
+    throw new Error(`Mounted FS is missing ${WEB_APP_DIR} (empack pack dir/append webApp?)`);
+  }
+}
+async function loadRmainFactory(runtimeBaseUrl) {
+  const { glue: glueUrl } = createRuntimeAssetUrls(runtimeBaseUrl);
+  const mod = await import(
+    /* webpackIgnore: true */
+    glueUrl.href
+  );
+  const factory = mod.default ?? mod.Rmain;
+  if (typeof factory !== "function") {
+    throw new Error(
+      "Rmain factory missing; rebuild r-main with -sMODULARIZE=1 -sEXPORT_NAME=Rmain -sEXPORT_ES6=1"
+    );
+  }
+  return factory;
+}
+function evalR(Module, code) {
+  if (Module._rWasmEvalDepth > 0) {
+    throw new Error("reentrant evalR");
+  }
+  Module._rWasmEvalDepth = 1;
+  try {
+    return Module.evalR(code);
+  } finally {
+    Module._rWasmEvalDepth = 0;
+    evalRPostFlush?.();
+  }
+}
+async function populateFromEmpack(module, {
+  empackMetaUrl,
+  empackPackagesBaseUrl,
+  onDownloadProgress: onDownloadProgress2,
+  onBootStatus: onBootStatus2
+}) {
+  if (typeof module.populateFilesystem !== "function") {
+    throw new Error(
+      "Module.populateFilesystem missing; rebuild r-main with the parameterized rmain_post.js"
+    );
+  }
+  onBootStatus2?.({
+    phase: "download",
+    message: "Loading packages\u2026",
+    percent: 5
+  });
+  lucentInfo("[rWasm] populateFilesystem", empackMetaUrl);
+  await module.populateFilesystem({
+    metaUrl: empackMetaUrl,
+    packagesBaseUrl: empackPackagesBaseUrl,
+    onProgress: onDownloadProgress2
+  });
+  await extractEmpackMountsIfNeeded(module, {
+    empackMetaUrl,
+    empackPackagesBaseUrl,
+    onDownloadProgress: onDownloadProgress2
+  });
+  onBootStatus2?.({
+    phase: "filesystem",
+    message: "Preparing filesystem\u2026",
+    percent: 62
+  });
+  clearVfsBlobUrlCache();
+  mountRHomeLibToSlashLib(module);
+  verifyMountedTree(module);
+}
+async function extractEmpackMountsIfNeeded(module, {
+  empackMetaUrl,
+  empackPackagesBaseUrl,
+  onDownloadProgress: onDownloadProgress2
+}) {
+  if (vfsExists(module, WEB_APP_DIR)) {
+    return;
+  }
+  const fetchUrls = module.fetchUrls;
+  if (typeof fetchUrls !== "function" || typeof module.extractArchiveFromMemory !== "function") {
+    return;
+  }
+  const metaHref = new URL(empackMetaUrl, self.location.href).href;
+  const metaRes = await fetch(metaHref);
+  if (!metaRes.ok) {
+    throw new Error(`Failed to fetch ${metaHref}: HTTP ${metaRes.status}`);
+  }
+  const meta = await metaRes.json();
+  const mounts = Array.isArray(meta.mounts) ? meta.mounts : [];
+  if (mounts.length === 0) {
+    return;
+  }
+  const baseHref = new URL(empackPackagesBaseUrl, self.location.href).href;
+  const urls = mounts.map((m) => {
+    if (!m?.filename) {
+      throw new Error(`mount entry missing filename in ${metaHref}`);
+    }
+    return new URL(m.filename, baseHref).href;
+  });
+  lucentInfo("[rWasm] extracting", urls.length, "empack mount archive(s)");
+  const errors = [];
+  await fetchUrls(urls, {
+    concurrency: 5,
+    onProgress: onDownloadProgress2,
+    onDone: async ({ url, arrayBuffer, error }) => {
+      if (error || !arrayBuffer) {
+        errors.push({ url, error: error ?? new Error("empty archive") });
+        return;
+      }
+      try {
+        module.extractArchiveFromMemory(new Uint8Array(arrayBuffer));
+      } catch (extractError) {
+        errors.push({ url, error: extractError });
+      }
+    }
+  });
+  if (errors.length > 0) {
+    const detail = errors.map((e) => `${e.url}: ${e.error instanceof Error ? e.error.message : String(e.error)}`).join("; ");
+    throw new Error(`Failed to extract empack mounts: ${detail}`);
+  }
+}
+function unloadTransportPackages(Module) {
+  evalR(Module, `tryCatch({
+  for (pkg in c("shiny", "httpuv")) {
+    if (pkg %in% loadedNamespaces()) {
+      tryCatch(unloadNamespace(pkg), error = function(e) {
+        cat("[rWasm] unloadNamespace ", pkg, ": ", conditionMessage(e), "\\n", sep = "")
+      })
+    }
+  }
+}, error = function(e) NULL)`);
+}
+async function remountRHome(Module, {
+  empackMetaUrl,
+  empackPackagesBaseUrl,
+  onDownloadProgress: onDownloadProgress2,
+  onBootStatus: onBootStatus2
+}) {
+  await populateFromEmpack(Module, {
+    empackMetaUrl,
+    empackPackagesBaseUrl,
+    onDownloadProgress: onDownloadProgress2,
+    onBootStatus: onBootStatus2
+  });
+  unloadTransportPackages(Module);
+  lucentInfo("[rWasm] Remounted empack env from", empackMetaUrl);
+}
+async function bootstrapRSession(Module, onBootStatus2) {
+  onBootStatus2?.({
+    phase: "init-r",
+    message: "Initializing R\u2026",
+    percent: 68
+  });
+  const status = Module.initR(["--no-restore", "--no-save", "--vanilla"]);
+  if (status !== 0) {
+    throw new Error(`R init failed with status ${status}`);
+  }
+  onBootStatus2?.({
+    phase: "load-httpuv",
+    message: "Loading httpuv\u2026",
+    percent: 78
+  });
+  evalR(Module, "suppressPackageStartupMessages(library(httpuv))");
+  evalR(Module, 'setwd("/")');
+  lucentInfo("[rWasm] R session ready");
+}
+async function initRModule({
+  runtimeBaseUrl,
+  empackMetaUrl,
+  empackPackagesBaseUrl,
+  print,
+  printErr,
+  onDownloadProgress: onDownloadProgress2,
+  onBootStatus: onBootStatus2
+}) {
+  const moduleRef = { current: null };
+  const locateFile = createFsBackedLocateFile(moduleRef, runtimeBaseUrl);
+  onBootStatus2?.({
+    phase: "load-runtime",
+    message: "Loading R.wasm runtime\u2026",
+    percent: 2
+  });
+  const createRmain = await loadRmainFactory(runtimeBaseUrl);
+  const module = {
+    noInitialRun: true,
+    _rWasmEvalDepth: 0,
+    locateFile,
+    onAbort(reason) {
+      throw new Error(`Rmain aborted: ${String(reason)}`);
+    },
+    print(text) {
+      (print ?? console.log)(String(text));
+    },
+    printErr(text) {
+      (printErr ?? console.error)(String(text));
+    }
+  };
+  moduleRef.current = module;
+  try {
+    await createRmain(module);
+  } catch (err) {
+    throw err instanceof Error ? err : new Error(String(err));
+  }
+  await populateFromEmpack(module, {
+    empackMetaUrl,
+    empackPackagesBaseUrl,
+    onDownloadProgress: onDownloadProgress2,
+    onBootStatus: onBootStatus2
+  });
+  await bootstrapRSession(module, onBootStatus2);
+  globalThis.Module = module;
+  return module;
+}
+
+// src/rWasmTasks.ts
+var SHINY_HOST = {
+  stop: `tryCatch({
+  if ("shiny" %in% loadedNamespaces() && shiny::isRunning()) {
+    shiny::stopApp()
+  }
+}, error=function(e) NULL)`,
+  suspend: `tryCatch(shiny::suspendServiceLoop(), error=function(e) NULL)`,
+  resume: `tryCatch(shiny::resumeServiceLoop(), error=function(e) NULL)`,
+  serviceOnce: `tryCatch(shiny::serviceOnce(), error=function(e) NULL)`,
+  /**
+   * Run serviceOnce and write status JSON to a VFS flag file.
+   * Module.evalR returns an SEXP pointer, not the R value — callers must read
+   * the flag file for hadWork / nextMs. The host arms delays from nextMs on
+   * SERVICE_STATUS (serviceOnce itself does not scheduleHostDelay).
+   *
+   * Before the app starts this reports idle in plain base R: a service tick must
+   * never be the thing that loads shiny.
+   */
+  serviceOnceHadWork: `tryCatch({
+  if (!("shiny" %in% loadedNamespaces())) {
+    cat("0", file = "/tmp/lucent-service-had-work")
+    invisible(FALSE)
+  } else {
+    had <- isTRUE(shiny::serviceOnce())
+    pending_flush <- tryCatch(shiny:::appsNeedingFlush$size() > 0, error=function(e) FALSE)
+    if (isTRUE(pending_flush)) {
+      had <- TRUE
+    }
+    next_ms <- tryCatch(shiny:::timerCallbacks$timeToNextEvent(), error=function(e) NA_real_)
+    jsonlite::write_json(list(
+      had = isTRUE(had),
+      nextMs = if (is.finite(next_ms)) next_ms else -1
+    ), "/tmp/lucent-service-had-work", auto_unbox=TRUE)
+    invisible(had)
+  }
+}, error=function(e) {
+  tryCatch(jsonlite::write_json(list(had=FALSE, nextMs=-1, err=conditionMessage(e)), "/tmp/lucent-service-had-work", auto_unbox=TRUE), error=function(e2) NULL)
+  invisible(FALSE)
+})`
+};
+function createRTaskQueue(rt) {
+  const macrotaskChannel = new MessageChannel();
+  const macrotaskQueue = [];
+  macrotaskChannel.port1.onmessage = () => {
+    const cb = macrotaskQueue.shift();
+    if (cb) {
+      cb();
+    }
+  };
+  function scheduleMacrotask(cb) {
+    macrotaskQueue.push(cb);
+    macrotaskChannel.port2.postMessage(0);
+  }
+  const rTaskQueue = [];
+  let rDrainScheduled = false;
+  let rLocked = false;
+  function scheduleRDrain() {
+    if (rDrainScheduled) {
+      return;
+    }
+    rDrainScheduled = true;
+    scheduleMacrotask(drainRTaskQueue);
+  }
+  function drainRTaskQueue() {
+    rDrainScheduled = false;
+    if (!rt.getModule() || rTaskQueue.length === 0) {
+      return;
+    }
+    const task = rTaskQueue.shift();
+    if (!task) {
+      return;
+    }
+    rLocked = true;
+    try {
+      task.work();
+      task.resolve();
+    } catch (err) {
+      task.reject(err);
+    } finally {
+      rLocked = false;
+      rt.getTransport()?.flushDeferredOutbound();
+    }
+    if (rTaskQueue.length > 0) {
+      scheduleRDrain();
+    }
+  }
+  function enqueueRTask(work) {
+    return new Promise((resolve, reject) => {
+      rTaskQueue.push({ work, resolve, reject });
+      scheduleRDrain();
+    });
+  }
+  function evalRNow(code) {
+    const module = rt.getModule();
+    if (!module) {
+      throw new Error("[lucent] R module not initialized yet");
+    }
+    return evalR(module, code);
+  }
+  return {
+    scheduleMacrotask,
+    enqueueRTask,
+    evalRNow,
+    isRLocked: () => rLocked,
+    hasPendingRTasks: () => rTaskQueue.length > 0
+  };
+}
+
+// src/rWasmHttpDelivery.ts
+var HTTP_PUSH_DRAIN_ROUNDS = 128;
+function createHttpDelivery(deps) {
+  let httpIdleMaxMs = 3e4;
+  let httpDeliveryActive = false;
+  let httpDeliveryDraining = false;
+  let shinyLoopSuspended = false;
+  let httpDeliveryInflight = 0;
+  const httpDeliveryQueue = [];
+  const httpDrainByUuid = /* @__PURE__ */ new Map();
+  async function idleWaitForHttpResponse(state, uuid, maxMs = httpIdleMaxMs) {
+    const start = Date.now();
+    if (!state.resolved) {
+      await new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          clearTimeout(timer);
+          if (state.notify === done) {
+            state.notify = void 0;
+          }
+          resolve();
+        };
+        state.notify = done;
+        const timer = setTimeout(done, maxMs);
+        if (state.resolved) {
+          done();
+        }
+      });
+    }
+    deps.dbg("worker-push-idle-done", {
+      uuid,
+      resolved: state.resolved,
+      waitedMs: Date.now() - start
+    });
+  }
+  function isStaticAssetUrl(url) {
+    return deps.requireTransport().isLikelyStaticAsset(url);
+  }
+  function isSessionHttpUrl(url) {
+    const t = deps.requireTransport();
+    try {
+      return t.isSessionHttpRequest(url, t.getShinyPrefix());
+    } catch {
+      return t.isSessionHttpRequest(url);
+    }
+  }
+  async function ensureShinyLoopSuspended() {
+    if (shinyLoopSuspended || !deps.getModule()) {
+      return;
+    }
+    await deps.tasks.enqueueRTask(() => {
+      deps.tasks.evalRNow(SHINY_HOST.suspend);
+    });
+    shinyLoopSuspended = true;
+    deps.dbg("worker-shiny-loop-suspend", {});
+  }
+  async function ensureShinyLoopResumed() {
+    if (!shinyLoopSuspended || !deps.getModule()) {
+      return;
+    }
+    await deps.tasks.enqueueRTask(() => {
+      deps.tasks.evalRNow(SHINY_HOST.resume);
+    });
+    shinyLoopSuspended = false;
+    deps.dbg("worker-shiny-loop-resume", {});
+  }
+  async function maybeFinishHttpDeliveryBatch() {
+    if (httpDeliveryQueue.length > 0 || httpDeliveryInflight > 0) {
+      return;
+    }
+    await ensureShinyLoopResumed();
+    httpDeliveryActive = false;
+    httpDeliveryDraining = false;
+  }
+  function drainAfterHttpPush(roundsLeft, uuid, state) {
+    if (roundsLeft <= 0 || !deps.getModule() || state.resolved) {
+      if (!state.resolved) {
+        deps.dbg("worker-push-drain-exhausted", { uuid, roundsLeft });
+      }
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      deps.tasks.scheduleMacrotask(() => {
+        void deps.tasks.enqueueRTask(() => {
+          deps.tasks.evalRNow(SHINY_HOST.serviceOnce);
+        }).then(() => drainAfterHttpPush(roundsLeft - 1, uuid, state)).then(resolve);
+      });
+    });
+  }
+  function yieldMacrotask() {
+    return new Promise((resolve) => {
+      deps.tasks.scheduleMacrotask(() => resolve());
+    });
+  }
+  async function deliverOneHttpRequest(req) {
+    const uuid = req.uuid ?? "";
+    const url = req.url ?? "";
+    const state = { resolved: false };
+    httpDrainByUuid.set(uuid, state);
+    httpDeliveryInflight++;
+    const staticAsset = isStaticAssetUrl(url);
+    const sessionHttp = isSessionHttpUrl(url);
+    try {
+      await deps.tasks.enqueueRTask(() => {
+        deps.requireTransport().pushInboundHostMessage(req);
+      });
+      if (!staticAsset) {
+        await idleWaitForHttpResponse(state, uuid, httpIdleMaxMs);
+        if (!state.resolved) {
+          await drainAfterHttpPush(HTTP_PUSH_DRAIN_ROUNDS, uuid, state);
+        } else if (sessionHttp) {
+          deps.dbg("worker-session-skip-drain", { uuid });
+        }
+      } else if (!state.resolved) {
+        await yieldMacrotask();
+      }
+    } finally {
+      httpDrainByUuid.delete(uuid);
+      httpDeliveryInflight--;
+      if (sessionHttp) {
+        deps.requestService();
+      }
+    }
+  }
+  async function drainHttpDeliveryQueue() {
+    while (httpDeliveryQueue.length > 0) {
+      const item = httpDeliveryQueue.shift();
+      if (!item) {
+        break;
+      }
+      const itemUrl = item.req.url ?? "";
+      const needsSuspend = !isStaticAssetUrl(itemUrl) && !isSessionHttpUrl(itemUrl);
+      if (needsSuspend && !shinyLoopSuspended) {
+        await ensureShinyLoopSuspended();
+      }
+      if (needsSuspend) {
+        httpDeliveryActive = true;
+      }
+      try {
+        await deliverOneHttpRequest(item.req);
+        item.resolve();
+      } catch (err) {
+        deps.logError(err, itemUrl);
+        item.reject(err);
+      } finally {
+        if (needsSuspend) {
+          httpDeliveryActive = false;
+        }
+      }
+      const next = httpDeliveryQueue[0];
+      const nextUrl = next?.req.url ?? "";
+      const nextNeedsSuspend = Boolean(
+        next && !isStaticAssetUrl(nextUrl) && !isSessionHttpUrl(nextUrl)
+      );
+      if (shinyLoopSuspended && !nextNeedsSuspend) {
+        await ensureShinyLoopResumed();
+      }
+    }
+    await maybeFinishHttpDeliveryBatch();
+    if (httpDeliveryQueue.length > 0 && !httpDeliveryDraining) {
+      httpDeliveryDraining = true;
+      void drainHttpDeliveryQueue();
+    }
+  }
+  function enqueueHttpDelivery(req) {
+    deps.requestService();
+    deps.dbg("worker-push", { uuid: req.uuid, method: req.method, url: req.url });
+    return new Promise((resolve, reject) => {
+      httpDeliveryQueue.push({ req, resolve, reject });
+      if (!httpDeliveryDraining) {
+        httpDeliveryDraining = true;
+        void drainHttpDeliveryQueue().catch((err) => {
+          httpDeliveryDraining = false;
+          httpDeliveryActive = false;
+          deps.logError(err);
+        });
+      }
+    });
+  }
+  return {
+    setIdleMaxMs(ms) {
+      httpIdleMaxMs = ms;
+    },
+    isHttpDeliveryActive: () => httpDeliveryActive,
+    hasHttpWork: () => httpDeliveryInflight > 0 || httpDeliveryQueue.length > 0,
+    noteHttpResponse(uuid) {
+      const drainState = uuid ? httpDrainByUuid.get(uuid) : void 0;
+      if (!drainState || drainState.resolved) {
+        return;
+      }
+      drainState.resolved = true;
+      drainState.notify?.();
+    },
+    enqueueHttpDelivery
+  };
+}
+
+// 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
+function createRHostApi(httpRequestType, handlers) {
+  const { onHttpRequest, onStop, getResourcePaths, registerSwDelivery, readVfsFile: readVfsFile2, readVfsFileAt: readVfsFileAt2 } = handlers;
+  return {
+    registerSwDelivery(port, wsPushPort2) {
+      registerSwDelivery(port, wsPushPort2);
+    },
+    deliverHttpRequest(req) {
+      return onHttpRequest({
+        type: httpRequestType,
+        uuid: req.uuid,
+        method: req.method,
+        url: req.url,
+        headers: req.headers ?? {},
+        body: req.body ?? null,
+        clientId: req.clientId ?? null
+      });
+    },
+    getShinyResourcePaths() {
+      return getResourcePaths();
+    },
+    readVfsFile(vfsDir, suffix) {
+      return readVfsFile2(vfsDir, suffix);
+    },
+    readVfsFileAt(vfsPath) {
+      return readVfsFileAt2(vfsPath);
+    },
+    stop() {
+      onStop();
+    }
+  };
+}
+
+// src/rWasmWorker.ts
+var workerSelf = self;
+var config = resolveLucentConfig();
+var rAssetBaseUrl = null;
+var mountedRuntimeKey = null;
+var transport = null;
+var rModule = null;
+var rModulePromise = null;
+var swDelivery = null;
+var wsPushPort = null;
+var rHostPortReady = false;
+var swDeliveryPortReady = false;
+var tasks = createRTaskQueue({
+  getModule: () => rModule,
+  getTransport: () => transport
+});
+function postToHost(payload, transfer2 = []) {
+  workerSelf.postMessage(payload, transfer2);
+}
+function requestService() {
+  postToHost({ type: RWASM.NEED_SERVICE });
+}
+function requireTransport() {
+  if (!transport) {
+    throw new Error("[lucent] transport not loaded yet");
+  }
+  return transport;
+}
+function requireRModule() {
+  if (!rModule) {
+    throw new Error("[lucent] R module not initialized yet");
+  }
+  return rModule;
+}
+function dbg(stage, ...args) {
+  transport?.httpuvDebugLog(stage, ...args);
+}
+var http = createHttpDelivery({
+  tasks,
+  getModule: () => rModule,
+  requireTransport,
+  requestService,
+  dbg,
+  formatError: formatRWasmError,
+  logError: logHttpDeliveryError
+});
+function log(level, text) {
+  const msg = String(text);
+  if (level === "error" && msg.startsWith("Error")) {
+    postToHost({ type: RWASM.LOG, level: "error", text: msg });
+    return;
+  }
+  postToHost({ type: RWASM.LOG, level: "log", text: msg });
+}
+function maybeAnnounceComlinkReady() {
+  if (rHostPortReady && swDeliveryPortReady) {
+    postToHost({ type: RWASM.COMLINK_READY });
+  }
+}
+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 formatRWasmError(err) {
+  if (err instanceof Error) {
+    return err.message || err.name;
+  }
+  const WasmException = WebAssembly.Exception;
+  if (typeof WasmException !== "undefined" && err instanceof WasmException) {
+    const message = err.message;
+    if (typeof message === "string" && message) {
+      return message;
+    }
+    return "WebAssembly.Exception (likely WASM trap during R eval)";
+  }
+  if (typeof err === "object" && err !== null) {
+    const message = err.message;
+    if (typeof message === "string" && message) {
+      return message;
+    }
+    const text = String(err);
+    if (text !== "[object Object]" && text !== "[object WebAssembly.Exception]") {
+      return text;
+    }
+  }
+  return String(err);
+}
+function replyOk(id) {
+  if (id == null) {
+    return;
+  }
+  postToHost({ type: RWASM.EVAL_RESULT, id, ok: true });
+}
+function replyErr(id, err) {
+  if (id == null) {
+    return;
+  }
+  postToHost({
+    type: RWASM.EVAL_RESULT,
+    id,
+    ok: false,
+    error: formatRWasmError(err)
+  });
+}
+function logHttpDeliveryError(err, url) {
+  const where = url ? ` ${url}` : "";
+  console.error(`[rWasmWorker] deliverHttpRequest failed:${where}`, formatRWasmError(err), err);
+}
+function deliverToServiceWorker(outbound, transfer2 = []) {
+  const t = requireTransport();
+  if (!swDelivery) {
+    console.warn("[rWasmWorker] Service worker delivery API not connected");
+    return;
+  }
+  requestService();
+  if (outbound.type === t.MSG.HTTP_RESPONSE) {
+    dbg("comlink-deliver-http", { uuid: outbound.uuid, status: outbound.status });
+    http.noteHttpResponse(outbound.uuid);
+    const resp = {
+      uuid: outbound.uuid,
+      status: outbound.status,
+      headers: outbound.headers,
+      body: outbound.body
+    };
+    void swDelivery.deliverHttpResponse(transfer2.length > 0 ? transfer(resp, transfer2) : resp).catch((err) => {
+      console.error("[rWasmWorker] deliverHttpResponse failed:", formatRWasmError(err), err);
+    });
+    return;
+  }
+  if (outbound.type === t.MSG.WS_PUSH) {
+    const handle = t.normalizeSessionHandle(outbound.handle);
+    dbg("ws-push", {
+      handle,
+      wsType: outbound.wsType,
+      binary: outbound.binary,
+      messageLen: messageBodyLength(outbound.message)
+    });
+    if (!wsPushPort) {
+      console.warn("[rWasmWorker] WS push port not connected; dropping frame");
+      return;
+    }
+    const fullMsg = {
+      type: t.MSG.WS_PUSH,
+      handle,
+      binary: outbound.binary,
+      wsType: outbound.wsType,
+      message: outbound.message
+    };
+    try {
+      if (transfer2.length > 0) {
+        wsPushPort.postMessage(fullMsg, transfer2);
+      } else {
+        wsPushPort.postMessage(fullMsg);
+      }
+    } catch (err) {
+      console.error("[rWasmWorker] wsPushPort.postMessage failed:", formatRWasmError(err), err);
+    }
+  }
+}
+function pushToR(msg) {
+  const t = requireTransport();
+  if (msg?.uuid) {
+    dbg("worker-push-evalR-begin", { uuid: msg.uuid });
+  }
+  const isWs = msg?.type === t.CHANNEL.WS_OPEN || msg?.type === t.CHANNEL.WS_MESSAGE || msg?.type === t.CHANNEL.WS_CLOSE;
+  if (isWs) {
+    dbg("worker-push-ws", {
+      type: msg.type,
+      handle: t.normalizeSessionHandle(msg.handle),
+      binary: msg.binary,
+      messageLen: messageBodyLength(msg.message)
+    });
+  }
+  let pushOk = false;
+  try {
+    tasks.evalRNow(`tryCatch({
+  ${t.channelMessageToRExpr(msg)}
+}, error=function(e) {
+  msg <- paste0("[httpuv] push failed (", ${JSON.stringify(String(msg.url ?? ""))}, "): ", conditionMessage(e))
+  message(msg)
+  stop(msg)
+})`);
+    pushOk = true;
+  } catch (err) {
+    throw err;
+  } finally {
+    if (msg?.uuid) {
+      dbg("worker-push-evalR-finish", { uuid: msg.uuid, ok: pushOk });
+    }
+    void tasks.enqueueRTask(() => {
+      if (!rModule) {
+        return;
+      }
+      tasks.evalRNow(SHINY_HOST.serviceOnceHadWork);
+    }).catch((err) => {
+      const error = formatRWasmError(err);
+      if (/Maximum call stack size exceeded/i.test(error) && rModule) {
+        try {
+          tasks.evalRNow(`tryCatch({
+  for (s in shiny:::appsByToken$values()) {
+    priv <- s$.__enclos_env__$private
+    while (isTRUE(priv$busyCount > 0L)) {
+      s$decrementBusyCount()
+    }
+  }
+  invisible(NULL)
+}, error=function(e) NULL)`);
+        } catch {
+        }
+      }
+      console.warn("[rWasmWorker] post-push serviceOnce failed:", error);
+    });
+    requestService();
+  }
+}
+function installBridge(t) {
+  const shinyBase = new URL(config.shinyBaseUrl, self.location.href).href;
+  t.setShinyPrefix(t.resolveShinyPrefix(shinyBase));
+  setEvalRPostFlush(() => t.flushDeferredOutbound());
+  t.installHttpuvBridge({
+    installSwListener: false,
+    postOutbound: deliverToServiceWorker,
+    pushToR: (msg) => {
+      pushToR(msg);
+    },
+    requestHostService: () => {
+      requestService();
+    },
+    scheduleHostDelay: (delayMs) => {
+      postToHost({
+        type: RWASM.SCHEDULE_DELAY,
+        delayMs: Math.max(0, Number(delayMs) || 0)
+      });
+    }
+  });
+}
+function empackMountKey() {
+  return [
+    config.rRuntimeBaseUrl,
+    config.empackMetaUrl,
+    config.empackPackagesBaseUrl
+  ].join("\0");
+}
+function onDownloadProgress(progress) {
+  const pct = progress.percent == null ? "?" : `${progress.percent.toFixed(1)}%`;
+  lucentInfo(
+    `[rWasm] download ${pct} (${progress.downloadedBytes}/${progress.totalBytes})`
+  );
+  postToHost({
+    type: RWASM.DOWNLOAD_PROGRESS,
+    percent: progress.percent,
+    downloadedBytes: progress.downloadedBytes,
+    totalBytes: progress.totalBytes
+  });
+}
+function onBootStatus(status) {
+  lucentInfo(`[rWasm] boot [${status.phase}] ${status.message}`);
+  postToHost({
+    type: RWASM.BOOT_STATUS,
+    phase: status.phase,
+    message: status.message,
+    percent: status.percent
+  });
+}
+async function initEverything() {
+  transport = await loadTransport(config.transportBaseUrl);
+  http.setIdleMaxMs(transport.REQUEST_TIMEOUT_MS);
+  const runtimeBaseUrl = new URL(config.rRuntimeBaseUrl, self.location.href).href;
+  const empackMetaUrl = new URL(config.empackMetaUrl, self.location.href).href;
+  const empackPackagesBaseUrl = new URL(
+    config.empackPackagesBaseUrl,
+    self.location.href
+  ).href;
+  rAssetBaseUrl = runtimeBaseUrl;
+  const module = await initRModule({
+    runtimeBaseUrl,
+    empackMetaUrl,
+    empackPackagesBaseUrl,
+    print: (text) => log("log", text),
+    printErr: (text) => log("error", text),
+    onDownloadProgress,
+    onBootStatus
+  });
+  rModule = module;
+  mountedRuntimeKey = empackMountKey();
+  installBridge(transport);
+  return module;
+}
+function ensureRModule() {
+  if (!rModulePromise) {
+    rModulePromise = initEverything();
+  }
+  return rModulePromise;
+}
+function readVfsFileAt(vfsPath) {
+  const module = requireRModule();
+  const path = vfsPath.replace(/\/+$/, "");
+  if (!path.startsWith("/") || path.includes("..")) {
+    return null;
+  }
+  try {
+    const data = module.FS.readFile(path, { encoding: "binary" });
+    return data.buffer.slice(
+      data.byteOffset,
+      data.byteOffset + data.byteLength
+    );
+  } catch (err) {
+    log("error", `[rWasmWorker] readVfsFileAt failed ${path}: ${formatRWasmError(err)}`);
+    return null;
+  }
+}
+function readVfsFile(vfsDir, suffix) {
+  return ensureRModule().then(() => {
+    const rel = suffix.replace(/^\/+/, "");
+    if (!rel || rel.includes("..")) {
+      return null;
+    }
+    const path = `${vfsDir.replace(/\/$/, "")}/${rel}`;
+    return readVfsFileAt(path);
+  });
+}
+function readVfsFileAtAsync(vfsPath) {
+  return ensureRModule().then(() => readVfsFileAt(vfsPath));
+}
+function readShinyResourcePathsFromR() {
+  const module = requireRModule();
+  tasks.evalRNow(`tryCatch({
+  paths <- if (requireNamespace("shiny", quietly=TRUE)) as.list(shiny::resourcePaths()) else list()
+  jsonlite::write_json(paths, "/resourcePaths.json", auto_unbox=TRUE)
+}, error=function(e) {
+  jsonlite::write_json(list(), "/resourcePaths.json", auto_unbox=TRUE)
+})`);
+  const text = module.FS.readFile("/resourcePaths.json", { encoding: "utf8" });
+  try {
+    module.FS.unlink("/resourcePaths.json");
+  } catch {
+  }
+  const parsed = JSON.parse(text);
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function getShinyResourcePaths() {
+  return ensureRModule().then(() => {
+    let result = {};
+    return tasks.enqueueRTask(() => {
+      result = readShinyResourcePathsFromR();
+    }).then(() => result);
+  });
+}
+function exposeRHost(port) {
+  const t = requireTransport();
+  const api = createRHostApi(t.MSG.HTTP_REQUEST, {
+    onHttpRequest: (req) => ensureRModule().then(() => http.enqueueHttpDelivery(req)).catch((err) => {
+      logHttpDeliveryError(err);
+      throw err;
+    }),
+    onStop: () => {
+      void ensureRModule().then(() => {
+        void tasks.enqueueRTask(() => {
+          requireTransport().pushInboundHostMessage({ type: t.MSG.STOP });
+          tasks.evalRNow(SHINY_HOST.stop);
+        });
+      }).catch((err) => {
+        log("error", `[rWasmWorker] stop failed: ${formatRWasmError(err)}`);
+      });
+    },
+    getResourcePaths: () => getShinyResourcePaths(),
+    readVfsFile: (vfsDir, suffix) => readVfsFile(vfsDir, suffix),
+    readVfsFileAt: (vfsPath) => readVfsFileAtAsync(vfsPath),
+    registerSwDelivery: (deliveryPort, pushPort) => {
+      connectSwDelivery(deliveryPort, pushPort);
+    }
+  });
+  expose(api, port);
+  rHostPortReady = true;
+  lucentInfo("[rWasmWorker] Comlink: exposing unified host API");
+}
+function connectSwDelivery(port, pushPort) {
+  swDelivery = wrap(port);
+  wsPushPort = pushPort;
+  wsPushPort.start();
+  swDeliveryPortReady = true;
+  lucentInfo("[rWasmWorker] Comlink: connected to SW delivery API (+ WS push port)");
+  maybeAnnounceComlinkReady();
+}
+function stopRunningApp() {
+  if (!rModule) {
+    return Promise.resolve();
+  }
+  return tasks.enqueueRTask(() => {
+    tasks.evalRNow(SHINY_HOST.stop);
+  }).catch((err) => {
+    log("error", `[rWasmWorker] stopApp failed: ${formatRWasmError(err)}`);
+  });
+}
+async function onMessage(event) {
+  const data = event.data;
+  if (data?.type === RWASM.COMLINK_PORT && event.ports[0]) {
+    const port = event.ports[0];
+    port.start();
+    rHostPortReady = false;
+    swDeliveryPortReady = false;
+    swDelivery = null;
+    wsPushPort = null;
+    await ensureRModule();
+    exposeRHost(port);
+    return;
+  }
+  if (!data || typeof data.type !== "string") {
+    return;
+  }
+  switch (data.type) {
+    case RWASM.EVAL: {
+      try {
+        await ensureRModule();
+        await tasks.enqueueRTask(() => {
+          tasks.evalRNow(String(data.code ?? ""));
+        });
+        replyOk(data.id);
+        requestService();
+      } catch (err) {
+        if (data.id != null) {
+          replyErr(data.id, err);
+        } else {
+          log("error", `[rWasmWorker] eval failed: ${formatRWasmError(err)}`);
+        }
+      }
+      break;
+    }
+    case RWASM.REMOUNT_R_HOME: {
+      try {
+        await ensureRModule();
+        if (!rAssetBaseUrl) {
+          throw new Error("R runtime base URL is not set");
+        }
+        const force = Boolean(data.force);
+        const key = empackMountKey();
+        if (!force && mountedRuntimeKey === key) {
+          lucentInfo("[rWasmWorker] remount skipped (empack env unchanged)");
+          replyOk(data.id);
+          break;
+        }
+        const empackMetaUrl = new URL(config.empackMetaUrl, self.location.href).href;
+        const empackPackagesBaseUrl = new URL(
+          config.empackPackagesBaseUrl,
+          self.location.href
+        ).href;
+        await remountRHome(requireRModule(), {
+          empackMetaUrl,
+          empackPackagesBaseUrl,
+          onDownloadProgress,
+          onBootStatus
+        });
+        mountedRuntimeKey = key;
+        replyOk(data.id);
+      } catch (err) {
+        log("error", `[rWasmWorker] remount R_HOME failed: ${formatRWasmError(err)}`);
+        replyErr(data.id, err);
+      }
+      break;
+    }
+    case RWASM.STOP_APP: {
+      try {
+        await stopRunningApp();
+        if (data.id != null) {
+          postToHost({ type: RWASM.STOPPED, id: data.id });
+        }
+      } catch (err) {
+        log("error", `[rWasmWorker] stop failed: ${formatRWasmError(err)}`);
+      }
+      break;
+    }
+    case RWASM.SERVICE_TICK: {
+      try {
+        await ensureRModule();
+        let hadWork = false;
+        let nextDelayMs = -1;
+        await tasks.enqueueRTask(() => {
+          if (!rModule) {
+            return;
+          }
+          tasks.evalRNow(SHINY_HOST.serviceOnceHadWork);
+          try {
+            const raw = rModule.FS.readFile("/tmp/lucent-service-had-work", {
+              encoding: "utf8"
+            }).trim();
+            if (raw === "1" || raw === "0") {
+              hadWork = raw === "1";
+              nextDelayMs = -1;
+            } else {
+              const status = JSON.parse(raw);
+              hadWork = Boolean(status.had);
+              const ms = Number(status.nextMs);
+              nextDelayMs = Number.isFinite(ms) && ms >= 0 ? ms : -1;
+            }
+          } catch {
+            hadWork = false;
+            nextDelayMs = -1;
+          }
+        });
+        postToHost({ type: RWASM.SERVICE_STATUS, hadWork, nextDelayMs });
+      } catch (err) {
+        log("error", `[rWasmWorker] service tick failed: ${formatRWasmError(err)}`);
+        postToHost({ type: RWASM.SERVICE_STATUS, hadWork: false, nextDelayMs: -1 });
+      }
+      break;
+    }
+    case RWASM.GET_RESOURCE_PATHS: {
+      try {
+        const paths = await getShinyResourcePaths();
+        postToHost({ type: RWASM.RESOURCE_PATHS, id: data.id, paths });
+      } catch (err) {
+        postToHost({
+          type: RWASM.RESOURCE_PATHS,
+          id: data.id,
+          paths: {},
+          error: formatRWasmError(err)
+        });
+      }
+      break;
+    }
+  }
+}
+workerSelf.addEventListener("message", (event) => {
+  void onMessage(event);
+});
+void ensureRModule().then(() => postToHost({ type: RWASM.READY })).catch((err) => {
+  postToHost({
+    type: RWASM.ERROR,
+    message: err instanceof Error ? err.message : String(err)
+  });
+});
+/*! Bundled license information:
+
+comlink/dist/esm/comlink.mjs:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/
+//# sourceMappingURL=rWasmWorker.js.map
+//# sourceMappingURL=rWasmWorker.js.map