rnxsim 0.1.523 → 0.1.525

package/dist-lib/swift.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.523 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.525 | (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;
@@ -44,6 +44,255 @@ var import_ui = require("contrast-kit/ui");
 var import_react = require("react");
 var import_react_native = require("react-native");
 var import_react_native_bottom_tabs = __toESM(require("react-native-bottom-tabs"), 1);
+
+// ../sootsim-swift/src/bundleAssets.ts
+function resolveImageSource(source, table, onMiss) {
+  if (typeof source !== "string") return source;
+  const url = table[source];
+  if (typeof url === "string") return { uri: url };
+  onMiss(source);
+  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) {
   return typeof value === "object" && value !== null;
@@ -93,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,
@@ -107,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) {
@@ -131,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,
@@ -195,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");
@@ -208,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)) {
@@ -266,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) {
@@ -317,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;
@@ -392,10 +691,12 @@ var SwiftResourcesContext = (0, import_react.createContext)(void 0);
 function SwiftImage(props) {
   const table = (0, import_react.useContext)(SwiftResourcesContext);
   const { source, ...rest } = props ?? {};
-  const url = typeof source === "string" ? table?.[source] : void 0;
+  const resolved = resolveImageSource(source, table ?? {}, (name) => {
+    console.error(`swift: no bundle asset named '${name}' in this mount's resources`);
+  });
   return (0, import_react.createElement)(import_ui.Image, {
     ...rest,
-    ...source === void 0 ? {} : { source: typeof url === "string" ? { uri: url } : source }
+    ...source === void 0 ? {} : { source: resolved }
   });
 }
 var NODE_COMPONENTS = {
@@ -637,8 +938,8 @@ function nodeProps(node, deliver) {
       return {
         ...typeof props.systemName === "string" ? { systemName: props.systemName } : {},
         // a bundle asset name rides as the kit image source; the kit paints
-        // its placeholder until its named-source lane lands (contrast-kit,
-        // not this mount row).
+        // resolved { uri } sources and keeps its placeholder for names the
+        // table could not resolve.
         ...typeof props.name === "string" ? { source: props.name } : {},
         ...props.resizable === true ? { resizable: true } : {},
         ...typeof props.renderingMode === "string" ? { renderingMode: props.renderingMode } : {},
@@ -678,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) => {
@@ -1192,10 +1495,18 @@ function SwiftTree({
     // a navigation stack at the root lays its own bar out under the status
     // bar and insets each screen itself, so the host must not also pad it
     // down: that pad would move the whole stack a status bar lower
+    // a swiftui scene is opaque: the window behind every screen is
+    // systemBackground, and lists paint their grouped fill over it (the kit's
+    // grouped container already does). without this a listless screen shows
+    // whatever sits beneath the mount. RAN on the safeArea probe (iphone 17
+    // pro): (600,1300) reads #ffffff ios against #f2f2f7 rnx, 99.92% of the
+    // frame; dark matches on both legs (the oracle's falsifier: the two
+    // fills coincide there). PlatformColor is this lane's spelling for a
+    // semantic color.
     /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
       import_ui.Host,
       {
-        style: { flex: 1 },
+        style: { flex: 1, backgroundColor: (0, import_react_native.PlatformColor)("systemBackground") },
         ignoreSafeArea: tree.some(
           (node) => node.t === "NavigationStack" || node.t === "NavigationSplitView"
         ),
@@ -1234,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;
@@ -1275,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;