rnxsim 0.1.524 → 0.1.526

package/dist-lib/swift-submit.cjs

@@ -0,0 +1,92 @@
+/*! rnx v0.1.526 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/swift-submit.ts
+var swift_submit_exports = {};
+__export(swift_submit_exports, {
+  SWIFT_COMPILE_PATH: () => SWIFT_COMPILE_PATH,
+  compileSwiftProject: () => compileSwiftProject,
+  httpSwiftCompileSubmit: () => httpSwiftCompileSubmit
+});
+module.exports = __toCommonJS(swift_submit_exports);
+var SWIFT_COMPILE_PATH = "/api/swift-compile";
+var POLL_INTERVAL_MS = 1500;
+function httpSwiftCompileSubmit(context) {
+  const { assetReadToken, endpoint } = context;
+  if (!assetReadToken) return void 0;
+  const url = endpoint ? `${endpoint.replace(/\/+$/, "")}${SWIFT_COMPILE_PATH}` : SWIFT_COMPILE_PATH;
+  return async (work) => {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ ...work, token: assetReadToken })
+      });
+    } catch (error) {
+      throw new Error(
+        `contrast-bundler: fetch failed for ${url} while compiling ${work.entry}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+    if (!response.ok) {
+      const detail = (await response.text()).trim();
+      throw new Error(
+        `contrast-bundler: the swift compile for ${work.entry} answered ${response.status}${detail ? `: ${detail}` : ""}`
+      );
+    }
+    return await response.json();
+  };
+}
+function resolveImageUrls(urls, origin) {
+  const resolved = {};
+  for (const [name, url] of Object.entries(urls)) {
+    resolved[name] = new URL(url, origin).href;
+  }
+  return resolved;
+}
+async function compileSwiftProject(submit, work, origin) {
+  while (true) {
+    const outcome = await submit(work);
+    switch (outcome.status) {
+      case "published":
+        return {
+          url: new URL(outcome.artifactUrl, origin).href,
+          hash: outcome.hash,
+          ...outcome.imageUrls === void 0 ? {} : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }
+        };
+      case "compiling":
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        continue;
+      case "refused":
+      case "failed":
+        throw new Error(
+          `contrast-bundler: the swift sources for ${work.entry} cannot be compiled: ${outcome.detail}`
+        );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SWIFT_COMPILE_PATH,
+  compileSwiftProject,
+  httpSwiftCompileSubmit
+});

package/dist-lib/swift-submit.mjs

@@ -0,0 +1,65 @@
+/*! rnx v0.1.526 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+
+// src/swift-submit.ts
+var SWIFT_COMPILE_PATH = "/api/swift-compile";
+var POLL_INTERVAL_MS = 1500;
+function httpSwiftCompileSubmit(context) {
+  const { assetReadToken, endpoint } = context;
+  if (!assetReadToken) return void 0;
+  const url = endpoint ? `${endpoint.replace(/\/+$/, "")}${SWIFT_COMPILE_PATH}` : SWIFT_COMPILE_PATH;
+  return async (work) => {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ ...work, token: assetReadToken })
+      });
+    } catch (error) {
+      throw new Error(
+        `contrast-bundler: fetch failed for ${url} while compiling ${work.entry}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+    if (!response.ok) {
+      const detail = (await response.text()).trim();
+      throw new Error(
+        `contrast-bundler: the swift compile for ${work.entry} answered ${response.status}${detail ? `: ${detail}` : ""}`
+      );
+    }
+    return await response.json();
+  };
+}
+function resolveImageUrls(urls, origin) {
+  const resolved = {};
+  for (const [name, url] of Object.entries(urls)) {
+    resolved[name] = new URL(url, origin).href;
+  }
+  return resolved;
+}
+async function compileSwiftProject(submit, work, origin) {
+  while (true) {
+    const outcome = await submit(work);
+    switch (outcome.status) {
+      case "published":
+        return {
+          url: new URL(outcome.artifactUrl, origin).href,
+          hash: outcome.hash,
+          ...outcome.imageUrls === void 0 ? {} : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }
+        };
+      case "compiling":
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        continue;
+      case "refused":
+      case "failed":
+        throw new Error(
+          `contrast-bundler: the swift sources for ${work.entry} cannot be compiled: ${outcome.detail}`
+        );
+    }
+  }
+}
+export {
+  SWIFT_COMPILE_PATH,
+  compileSwiftProject,
+  httpSwiftCompileSubmit
+};

package/dist-lib/swift.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.524 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.526 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;
@@ -54,6 +54,244 @@ function resolveImageSource(source, table, onMiss) {
   return source;
 }
 
+// ../sootsim-swift/src/resfs.ts
+var RES_BADF = 8;
+var RES_INVAL = 28;
+var RES_NOENT = 44;
+var RES_NOTDIR = 54;
+var RES_NOTCAPABLE = 76;
+var RES_DIRTYPE = 3;
+var RES_FILETYPE = 4;
+var O_CREAT = 1;
+var O_DIRECTORY = 2;
+var O_EXCL = 4;
+var O_TRUNC = 8;
+var RES_PREOPEN = 3;
+var RES_DIR_NAME = "/res";
+var B64_DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function decodeBase64(text) {
+  const clean = text.replace(/\s/g, "");
+  if (clean.length % 4 !== 0) {
+    throw new Error(`swift bundle file is not base64 (length ${clean.length})`);
+  }
+  const values = new Uint8Array(clean.length);
+  let length = clean.length;
+  let pad = 0;
+  if (clean.endsWith("==")) pad = 2;
+  else if (clean.endsWith("=")) pad = 1;
+  length -= pad;
+  for (let index = 0; index < clean.length - pad; index += 1) {
+    const digit = B64_DIGITS.indexOf(clean[index]);
+    if (digit < 0) {
+      throw new Error(`swift bundle file is not base64 (char '${clean[index]}')`);
+    }
+    values[index] = digit;
+  }
+  const out = new Uint8Array((clean.length / 4 | 0) * 3 - pad);
+  let at = 0;
+  for (let index = 0; index < clean.length; index += 4) {
+    const group = values[index] << 18 | values[index + 1] << 12 | values[index + 2] << 6 | values[index + 3];
+    out[at] = group >> 16 & 255;
+    if (at + 1 < out.length) out[at + 1] = group >> 8 & 255;
+    if (at + 2 < out.length) out[at + 2] = group & 255;
+    at += 3;
+  }
+  return out;
+}
+function resIno(name) {
+  let hash = 0xcbf29ce484222325n;
+  const bytes = new TextEncoder().encode(name);
+  for (const byte of bytes) {
+    hash ^= BigInt(byte);
+    hash = hash * 0x100000001b3n & 0xffffffffffffffffn;
+  }
+  return hash === 0n ? 1n : hash;
+}
+function resArgv0(moduleUrl) {
+  const base = moduleUrl.split("/").pop()?.split("?")[0] ?? "app.wasm";
+  return `${RES_DIR_NAME}/${base === "" ? "app.wasm" : base}`;
+}
+function resolveName(files, rel) {
+  let rest = rel;
+  if (rest === RES_DIR_NAME || rest === `${RES_DIR_NAME}/`) return null;
+  if (rest.startsWith(`${RES_DIR_NAME}/`)) rest = rest.slice(RES_DIR_NAME.length + 1);
+  if (rest.startsWith("/")) rest = rest.slice(1);
+  while (rest.startsWith("./")) rest = rest.slice(2);
+  if (rest === "" || rest === ".") return null;
+  if (rest.includes("/")) return null;
+  return Object.prototype.hasOwnProperty.call(files, rest) ? rest : null;
+}
+function writeStat(mem, ptr, filetype, size, ino) {
+  mem.bytes().fill(0, ptr, ptr + 64);
+  mem.bytes()[ptr + 16] = filetype;
+  mem.writeU64(ptr + 8, ino);
+  mem.writeU64(ptr + 32, BigInt(size));
+}
+function createResFs(files) {
+  const names = Object.keys(files).sort();
+  const fds = /* @__PURE__ */ new Map();
+  let nextFd = RES_PREOPEN + 1;
+  const freeFds = [];
+  let preopenOpen = true;
+  const allocFd = () => {
+    if (freeFds.length > 0) return freeFds.shift();
+    nextFd += 1;
+    return nextFd - 1;
+  };
+  const dirFdOk = (fd) => {
+    if (fd === RES_PREOPEN) return preopenOpen;
+    const found = fds.get(fd);
+    return found !== void 0 && found.kind === "dir";
+  };
+  const inoOf = (name) => resIno(name);
+  return {
+    imports(mem) {
+      return {
+        path_open: (dirfd, _dirflags, pathPtr, pathLen, oflags, _r1, _r2, _r3, fdPtr) => {
+          if (!dirFdOk(dirfd)) return RES_BADF;
+          if ((oflags & (O_CREAT | O_EXCL | O_TRUNC)) !== 0) return RES_INVAL;
+          const rel = mem.readString(pathPtr, pathLen);
+          if (rel === "." || rel === "./" || rel === RES_DIR_NAME || rel === `${RES_DIR_NAME}/`) {
+            const fd2 = allocFd();
+            fds.set(fd2, { kind: "dir" });
+            mem.writeU32(fdPtr, fd2);
+            return 0;
+          }
+          const hit = resolveName(files, rel);
+          if (hit === null) return RES_NOENT;
+          if ((oflags & O_DIRECTORY) !== 0) return RES_NOTDIR;
+          const fd = allocFd();
+          fds.set(fd, { kind: "file", name: hit, bytes: files[hit], offset: 0 });
+          mem.writeU32(fdPtr, fd);
+          return 0;
+        },
+        path_filestat_get: (dirfd, _flags, pathPtr, pathLen, statPtr) => {
+          if (!dirFdOk(dirfd)) return RES_BADF;
+          const rel = mem.readString(pathPtr, pathLen);
+          if (rel === "." || rel === "./" || rel === RES_DIR_NAME || rel === `${RES_DIR_NAME}/`) {
+            writeStat(mem, statPtr, RES_DIRTYPE, 0, inoOf(RES_DIR_NAME));
+            return 0;
+          }
+          const hit = resolveName(files, rel);
+          if (hit === null) return RES_NOENT;
+          writeStat(mem, statPtr, RES_FILETYPE, files[hit].length, inoOf(hit));
+          return 0;
+        },
+        fd_fdstat_get: (fd, statPtr) => {
+          if (fd === RES_PREOPEN) {
+            if (!preopenOpen) return RES_BADF;
+            mem.bytes().fill(0, statPtr, statPtr + 24);
+            mem.bytes()[statPtr] = RES_DIRTYPE;
+            return 0;
+          }
+          const found = fds.get(fd);
+          if (!found) return RES_BADF;
+          mem.bytes().fill(0, statPtr, statPtr + 24);
+          mem.bytes()[statPtr] = found.kind === "dir" ? RES_DIRTYPE : RES_FILETYPE;
+          return 0;
+        },
+        fd_filestat_get: (fd, statPtr) => {
+          const found = fds.get(fd);
+          if (!found) return RES_BADF;
+          if (found.kind === "dir") {
+            writeStat(mem, statPtr, RES_DIRTYPE, 0, inoOf(RES_DIR_NAME));
+            return 0;
+          }
+          writeStat(mem, statPtr, RES_FILETYPE, found.bytes.length, inoOf(found.name));
+          return 0;
+        },
+        fd_prestat_get: (fd, prestatPtr) => {
+          if (fd === RES_PREOPEN && preopenOpen) {
+            mem.bytes().fill(0, prestatPtr, prestatPtr + 8);
+            mem.bytes()[prestatPtr] = 0;
+            mem.writeU32(prestatPtr + 4, RES_DIR_NAME.length);
+            return 0;
+          }
+          return RES_BADF;
+        },
+        fd_prestat_dir_name: (fd, pathPtr, pathLen) => {
+          if (fd !== RES_PREOPEN || !preopenOpen) return RES_BADF;
+          if (pathLen < RES_DIR_NAME.length) return RES_INVAL;
+          mem.bytes().set(new TextEncoder().encode(RES_DIR_NAME), pathPtr);
+          return 0;
+        },
+        fd_readdir: (fd, bufPtr, bufLen, cookie, usedPtr) => {
+          const isPreopen = fd === RES_PREOPEN && preopenOpen;
+          const found = fds.get(fd);
+          if (!isPreopen && !found) return RES_BADF;
+          if (!isPreopen && found?.kind !== "dir") return RES_NOTCAPABLE;
+          let used = 0;
+          names.forEach((name, index) => {
+            const next = index + 1;
+            if (next <= cookie) return;
+            const encoded = new TextEncoder().encode(name);
+            if (used + 24 + encoded.length > bufLen) return;
+            const at = bufPtr + used;
+            mem.writeU64(at, BigInt(next));
+            mem.writeU64(at + 8, inoOf(name));
+            mem.writeU32(at + 16, encoded.length);
+            mem.bytes()[at + 20] = RES_FILETYPE;
+            mem.bytes().fill(0, at + 21, at + 24);
+            mem.bytes().set(encoded, at + 24);
+            used += 24 + encoded.length;
+          });
+          mem.writeU32(usedPtr, used);
+          return 0;
+        },
+        fd_read: (fd, iovsPtr, iovsLen, donePtr) => {
+          const found = fds.get(fd);
+          if (!found) return RES_BADF;
+          if (found.kind !== "file") return RES_NOTCAPABLE;
+          let done = 0;
+          for (let index = 0; index < iovsLen; index += 1) {
+            const ptr = mem.readU32(iovsPtr + index * 8);
+            const want = mem.readU32(iovsPtr + index * 8 + 4);
+            const chunk = found.bytes.subarray(found.offset, found.offset + want);
+            mem.bytes().set(chunk, ptr);
+            found.offset += chunk.length;
+            done += chunk.length;
+            if (chunk.length < want) break;
+          }
+          mem.writeU32(donePtr, done);
+          return 0;
+        },
+        // the tree is read-only: any write to it is not-capable, and an
+        // unknown fd is a bad descriptor. stdio never reaches here; the
+        // mount answers fds 0-2 itself before delegating.
+        fd_write: (fd, _iovsPtr, _iovsLen, _donePtr) => {
+          if (fd === RES_PREOPEN || fds.has(fd)) return RES_NOTCAPABLE;
+          return RES_BADF;
+        },
+        fd_pread: (fd, _iovsPtr, _iovsLen, _offset, _donePtr) => {
+          if (fd === RES_PREOPEN || fds.has(fd)) return RES_NOTCAPABLE;
+          return RES_BADF;
+        },
+        fd_seek: (fd, _offLo, _offHi, _whence, _posPtr) => {
+          if (fd === RES_PREOPEN || fds.has(fd)) return RES_NOTCAPABLE;
+          return RES_BADF;
+        },
+        fd_tell: (fd, _posPtr) => {
+          if (fd === RES_PREOPEN || fds.has(fd)) return RES_NOTCAPABLE;
+          return RES_BADF;
+        },
+        fd_close: (fd) => {
+          if (fd === RES_PREOPEN) {
+            if (!preopenOpen) return RES_BADF;
+            preopenOpen = false;
+            return 0;
+          }
+          if (!fds.has(fd)) return RES_BADF;
+          fds.delete(fd);
+          const at = freeFds.findIndex((other) => other > fd);
+          if (at < 0) freeFds.push(fd);
+          else freeFds.splice(at, 0, fd);
+          return 0;
+        }
+      };
+    }
+  };
+}
+
 // ../sootsim-swift/src/mount.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 function isRecord(value) {
@@ -104,12 +342,28 @@ function readTree(text) {
 }
 var WASI_BADF = 8;
 var WASI_INVAL = 28;
-function wasiImports(host) {
+function wasiImports(host, argv, resFiles) {
+  const argvBytes = argv.map((arg) => new TextEncoder().encode(`${arg}\0`));
+  const resImports = createResFs(resFiles).imports(host);
   return {
-    args_get: () => 0,
+    args_get: (argvPtr, bufPtr) => {
+      let argp = argvPtr;
+      let bufp = bufPtr;
+      for (const bytes of argvBytes) {
+        host.writeU32(argp, bufp);
+        host.bytes().set(bytes, bufp);
+        argp += 4;
+        bufp += bytes.length;
+      }
+      host.writeU32(argp, 0);
+      return 0;
+    },
     args_sizes_get: (argcPtr, argvSizePtr) => {
-      host.writeU32(argcPtr, 0);
-      host.writeU32(argvSizePtr, 0);
+      host.writeU32(argcPtr, argvBytes.length);
+      host.writeU32(
+        argvSizePtr,
+        argvBytes.reduce((total, bytes) => total + bytes.length, 0)
+      );
       return 0;
     },
     environ_get: () => 0,
@@ -118,21 +372,23 @@ function wasiImports(host) {
       host.writeU32(sizePtr, 0);
       return 0;
     },
-    fd_close: () => WASI_BADF,
-    fd_fdstat_get: () => WASI_BADF,
+    fd_close: (...args) => resImports.fd_close(...args),
+    fd_fdstat_get: (...args) => resImports.fd_fdstat_get(...args),
     fd_fdstat_set_flags: () => WASI_BADF,
-    fd_filestat_get: () => WASI_BADF,
+    fd_filestat_get: (...args) => resImports.fd_filestat_get(...args),
     fd_filestat_set_size: () => WASI_BADF,
     fd_filestat_set_times: () => WASI_BADF,
-    fd_pread: () => WASI_BADF,
-    fd_prestat_get: () => WASI_BADF,
-    fd_prestat_dir_name: () => WASI_BADF,
-    fd_read: () => WASI_BADF,
-    fd_readdir: () => WASI_BADF,
-    fd_seek: () => WASI_BADF,
+    fd_pread: (...args) => resImports.fd_pread(...args),
+    fd_prestat_get: (...args) => resImports.fd_prestat_get(...args),
+    fd_prestat_dir_name: (...args) => resImports.fd_prestat_dir_name(...args),
+    fd_read: (...args) => resImports.fd_read(...args),
+    fd_readdir: (...args) => resImports.fd_readdir(...args),
+    fd_seek: (...args) => resImports.fd_seek(...args),
     fd_sync: () => WASI_BADF,
-    fd_tell: () => WASI_BADF,
-    fd_write: (_fd, iovsPtr, iovsLen, writtenPtr) => {
+    fd_tell: (...args) => resImports.fd_tell(...args),
+    fd_write: (fd, iovsPtr, iovsLen, writtenPtr) => {
+      if (fd !== 1 && fd !== 2)
+        return resImports.fd_write(fd, iovsPtr, iovsLen, writtenPtr);
       const view = new DataView(host.bytes().buffer);
       let written = 0;
       for (let index = 0; index < iovsLen; index += 1) {
@@ -142,10 +398,10 @@ function wasiImports(host) {
       return 0;
     },
     path_create_directory: () => WASI_BADF,
-    path_filestat_get: () => WASI_BADF,
+    path_filestat_get: (...args) => resImports.path_filestat_get(...args),
     path_filestat_set_times: () => WASI_BADF,
     path_link: () => WASI_BADF,
-    path_open: () => WASI_BADF,
+    path_open: (...args) => resImports.path_open(...args),
     path_readlink: () => WASI_BADF,
     path_remove_directory: () => WASI_BADF,
     path_rename: () => WASI_BADF,
@@ -206,7 +462,7 @@ function voidExport(exports2, name) {
     Reflect.apply(fn, void 0, args);
   };
 }
-function instantiate(module2) {
+function instantiate(module2, bundle) {
   let memory;
   const requireMemory = () => {
     if (!memory) throw new Error("swift artifact memory is not live");
@@ -219,10 +475,19 @@ function instantiate(module2) {
     writeU64(ptr, value) {
       new DataView(requireMemory().buffer).setBigUint64(ptr, value, true);
     },
+    readU32(ptr) {
+      return new DataView(requireMemory().buffer).getUint32(ptr, true);
+    },
+    readString(ptr, len) {
+      return new TextDecoder().decode(
+        new Uint8Array(requireMemory().buffer).subarray(ptr, ptr + len)
+      );
+    },
     bytes: () => new Uint8Array(requireMemory().buffer)
   };
+  const argv = bundle === null ? [] : [bundle.argv0];
   const instance = new WebAssembly.Instance(module2, {
-    wasi_snapshot_preview1: wasiImports(host)
+    wasi_snapshot_preview1: wasiImports(host, argv, bundle?.files ?? {})
   });
   const exportedMemory = instance.exports.memory;
   if (!(exportedMemory instanceof WebAssembly.Memory)) {
@@ -277,7 +542,15 @@ function instantiate(module2) {
     return result;
   };
   initialize();
-  mainArgv(0, 0);
+  if (bundle === null) {
+    mainArgv(0, 0);
+  } else {
+    const encoded = new TextEncoder().encode(`${bundle.argv0}\0`);
+    const ptr = alloc(encoded.length + 4);
+    new Uint8Array(requireMemory().buffer).set(encoded, ptr + 4);
+    new DataView(requireMemory().buffer).setUint32(ptr, ptr + 4, true);
+    mainArgv(1, ptr);
+  }
   return {
     mount: () => {
       if (hasViewExport() === 1) {
@@ -328,6 +601,21 @@ function instantiate(module2) {
   };
 }
 var compiledModules = /* @__PURE__ */ new Map();
+function decodeBundle(moduleUrl, packed) {
+  if (packed === void 0) return null;
+  const files = {};
+  for (const [name, base64] of Object.entries(packed)) {
+    try {
+      files[name] = decodeBase64(base64);
+    } catch (error) {
+      throw new Error(
+        `swift bundle file '${name}' is not decodable: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (Object.keys(files).length === 0) return null;
+  return { files, argv0: resArgv0(moduleUrl) };
+}
 function compile(url) {
   const cached = compiledModules.get(url);
   if (cached) return cached;
@@ -691,6 +979,8 @@ function nodeProps(node, deliver) {
     }
     case "Button":
       return pressProps(node, deliver);
+    case "EditButton":
+      return pressProps(node, deliver);
     case "TabView": {
       const onSelect = handlerId(node, "onSelect");
       const tabs = (node.c ?? []).map((tab, index) => {
@@ -1255,7 +1545,10 @@ function createRoot(mountTree) {
   };
   const apply = async (options, props) => {
     const carried = instance?.exportState() ?? null;
-    const created = instantiate(await compile(options.url));
+    const created = instantiate(
+      await compile(options.url),
+      decodeBundle(options.url, options.bundleFiles)
+    );
     if (carried !== null) created.importState(carried);
     if (source !== options) return;
     instance = created;
@@ -1296,7 +1589,7 @@ function createRoot(mountTree) {
   return {
     component,
     use(options, refreshKey, props) {
-      const changed = source === null || source.hash !== options.hash || source.url !== options.url || JSON.stringify(source.resources ?? null) !== JSON.stringify(options.resources ?? null) || refreshKey !== void 0 && refreshKey !== refresh;
+      const changed = source === null || source.hash !== options.hash || source.url !== options.url || JSON.stringify(source.resources ?? null) !== JSON.stringify(options.resources ?? null) || JSON.stringify(source.bundleFiles ?? null) !== JSON.stringify(options.bundleFiles ?? null) || refreshKey !== void 0 && refreshKey !== refresh;
       if (changed) {
         source = options;
         refresh = refreshKey;