peachsim 0.1.527

package/dist-lib/swift.cjs

@@ -0,0 +1,1646 @@
+/*! rnx v0.1.527 | (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;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/swift.ts
+var swift_exports = {};
+__export(swift_exports, {
+  createSwiftEntry: () => createSwiftEntry
+});
+module.exports = __toCommonJS(swift_exports);
+
+// ../sootsim-swift/src/mount.tsx
+var import_native = require("@react-navigation/native");
+var import_native_stack = require("@react-navigation/native-stack");
+var import_runtime = require("contrast-kit/runtime");
+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;
+}
+function readModifier(value) {
+  if (!isRecord(value) || typeof value.$type !== "string") {
+    throw new Error("swift modifier is not a { $type } object");
+  }
+  return { ...value, $type: value.$type };
+}
+function readNode(value) {
+  if (!isRecord(value)) throw new Error("swift node is not an object");
+  const { t, id, p, m, c, h } = value;
+  if (typeof t !== "string" || typeof id !== "string") {
+    throw new Error("swift node has no type or identity");
+  }
+  const node = { t, id };
+  if (p !== void 0) {
+    if (!isRecord(p)) throw new Error(`swift node ${id} has a non-object props`);
+    node.p = p;
+  }
+  if (m !== void 0) {
+    if (!Array.isArray(m)) throw new Error(`swift node ${id} has a non-array modifiers`);
+    node.m = m.map(readModifier);
+  }
+  if (c !== void 0) {
+    if (!Array.isArray(c)) throw new Error(`swift node ${id} has non-array children`);
+    node.c = c.map(readNode);
+  }
+  if (h !== void 0) {
+    if (!isRecord(h)) throw new Error(`swift node ${id} has non-object handlers`);
+    const handlers = {};
+    for (const [name, handlerId2] of Object.entries(h)) {
+      if (typeof handlerId2 !== "number") {
+        throw new Error(`swift node ${id} handler ${name} is not a number`);
+      }
+      handlers[name] = handlerId2;
+    }
+    node.h = handlers;
+  }
+  return node;
+}
+function readTree(text) {
+  const value = JSON.parse(text);
+  if (!Array.isArray(value)) throw new Error("swift tree is not an array");
+  return value.map(readNode);
+}
+var WASI_BADF = 8;
+var WASI_INVAL = 28;
+function wasiImports(host, argv, resFiles) {
+  const argvBytes = argv.map((arg) => new TextEncoder().encode(`${arg}\0`));
+  const resImports = createResFs(resFiles).imports(host);
+  return {
+    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, argvBytes.length);
+      host.writeU32(
+        argvSizePtr,
+        argvBytes.reduce((total, bytes) => total + bytes.length, 0)
+      );
+      return 0;
+    },
+    environ_get: () => 0,
+    environ_sizes_get: (countPtr, sizePtr) => {
+      host.writeU32(countPtr, 0);
+      host.writeU32(sizePtr, 0);
+      return 0;
+    },
+    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: (...args) => resImports.fd_filestat_get(...args),
+    fd_filestat_set_size: () => WASI_BADF,
+    fd_filestat_set_times: () => 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: (...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) {
+        written += view.getUint32(iovsPtr + index * 8 + 4, true);
+      }
+      host.writeU32(writtenPtr, written);
+      return 0;
+    },
+    path_create_directory: () => WASI_BADF,
+    path_filestat_get: (...args) => resImports.path_filestat_get(...args),
+    path_filestat_set_times: () => WASI_BADF,
+    path_link: () => WASI_BADF,
+    path_open: (...args) => resImports.path_open(...args),
+    path_readlink: () => WASI_BADF,
+    path_remove_directory: () => WASI_BADF,
+    path_rename: () => WASI_BADF,
+    path_symlink: () => WASI_BADF,
+    path_unlink_file: () => WASI_BADF,
+    // the 6.3 sdk's libraries call the clocks even when the app never reads
+    // the time, so instantiation fails without them. clock 0 is realtime
+    // and clock 1 is monotonic, the only two swift asks for here; anything
+    // else is a loud inval. the resolutions are wasi-libc's for those two:
+    // a millisecond for the wall clock and a nanosecond for the monotonic one.
+    clock_res_get: (clockId, resolutionPtr) => {
+      const resolution = clockId === 1 ? 1n : clockId === 0 ? 1000000n : null;
+      if (resolution === null) return WASI_INVAL;
+      host.writeU64(resolutionPtr, resolution);
+      return 0;
+    },
+    clock_time_get: (clockId, _precision, timePtr) => {
+      const nanos = clockId === 1 ? BigInt(Math.round(performance.now() * 1e6)) : clockId === 0 ? BigInt(Date.now()) * 1000000n : null;
+      if (nanos === null) return WASI_INVAL;
+      host.writeU64(timePtr, nanos);
+      return 0;
+    },
+    // a poll is the one call the tenant cannot answer: there is no descriptor
+    // to wait on and no clock to sleep against, so it says so instead of
+    // returning an event nobody subscribed to.
+    poll_oneoff: () => {
+      throw new Error("swift app polled for events, which the tenant has no source for");
+    },
+    proc_exit: (code) => {
+      throw new Error(`swift app exited with code ${code}`);
+    },
+    random_get: (bufferPtr, length) => {
+      crypto.getRandomValues(host.bytes().subarray(bufferPtr, bufferPtr + length));
+      return 0;
+    }
+  };
+}
+function rawExport(exports2, name) {
+  const value = exports2[name];
+  if (typeof value !== "function") {
+    throw new Error(`swift artifact has no exported function ${name}`);
+  }
+  return value;
+}
+function pointerExport(exports2, name) {
+  const fn = rawExport(exports2, name);
+  return (...args) => {
+    const result = Reflect.apply(fn, void 0, args);
+    if (typeof result !== "number") {
+      throw new Error(`swift export ${name} returned ${typeof result}`);
+    }
+    return result;
+  };
+}
+function voidExport(exports2, name) {
+  const fn = rawExport(exports2, name);
+  return (...args) => {
+    Reflect.apply(fn, void 0, args);
+  };
+}
+function instantiate(module2, bundle) {
+  let memory;
+  const requireMemory = () => {
+    if (!memory) throw new Error("swift artifact memory is not live");
+    return memory;
+  };
+  const host = {
+    writeU32(ptr, value) {
+      new DataView(requireMemory().buffer).setUint32(ptr, value, true);
+    },
+    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, argv, bundle?.files ?? {})
+  });
+  const exportedMemory = instance.exports.memory;
+  if (!(exportedMemory instanceof WebAssembly.Memory)) {
+    throw new Error("swift artifact does not export its memory");
+  }
+  memory = exportedMemory;
+  const initialize = voidExport(instance.exports, "_initialize");
+  const mainArgv = voidExport(instance.exports, "__main_argc_argv");
+  const mount = pointerExport(instance.exports, "rnx_mount");
+  const mountViewExport = pointerExport(instance.exports, "rnx_mount_view");
+  const hasViewExport = pointerExport(instance.exports, "rnx_has_view");
+  const event = pointerExport(instance.exports, "rnx_event");
+  const stateExport = pointerExport(instance.exports, "rnx_state_export");
+  const stateImport = voidExport(instance.exports, "rnx_state_import");
+  const alloc = pointerExport(instance.exports, "rnx_alloc");
+  const free = voidExport(instance.exports, "rnx_free");
+  const openURLDrain = typeof instance.exports.rnx_open_url_drain === "function" ? pointerExport(instance.exports, "rnx_open_url_drain") : null;
+  const drainOpenURLs = () => {
+    if (!openURLDrain) return;
+    let urls;
+    try {
+      urls = JSON.parse(readBuffer(openURLDrain()));
+    } catch {
+      return;
+    }
+    if (!Array.isArray(urls)) return;
+    for (const url of urls) {
+      if (typeof url !== "string") continue;
+      import_react_native.Linking.canOpenURL(url).then(
+        (open) => {
+          if (open) import_react_native.Linking.openURL(url).catch(() => {
+          });
+        },
+        () => {
+        }
+      );
+    }
+  };
+  const readBuffer = (ptr) => {
+    const view = new DataView(requireMemory().buffer);
+    const length = view.getUint32(ptr, true);
+    return new TextDecoder().decode(
+      new Uint8Array(requireMemory().buffer, ptr + 4, length)
+    );
+  };
+  const withPayload = (value, run) => {
+    const encoded = new TextEncoder().encode(JSON.stringify(value));
+    const ptr = alloc(encoded.length);
+    new Uint8Array(requireMemory().buffer).set(encoded, ptr);
+    const result = run(ptr, encoded.length);
+    free(ptr);
+    return result;
+  };
+  initialize();
+  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) {
+        throw new Error(
+          "swift package has an RNXPackage entry, not an App entry; mount it as a view or make its @main type conform to App"
+        );
+      }
+      const tree = readTree(readBuffer(mount()));
+      drainOpenURLs();
+      return tree;
+    },
+    mountView: (props) => {
+      if (hasViewExport() !== 1) {
+        throw new Error(
+          "swift package has no RNXPackage entry; its @main type must conform to RNXPackage to mount as a view"
+        );
+      }
+      const tree = readTree(
+        readBuffer(withPayload(props, (ptr, length) => mountViewExport(ptr, length)))
+      );
+      drainOpenURLs();
+      return tree;
+    },
+    hasView: () => hasViewExport() === 1,
+    deliver: (handlerId2, payload) => {
+      const tree = readTree(
+        readBuffer(
+          withPayload(
+            payload,
+            (ptr, length) => (
+              // handler ids are opaque to the tenant: they come from the tree
+              // this instance just returned and they are only meaningful to it
+              event(handlerId2, ptr, length)
+            )
+          )
+        )
+      );
+      drainOpenURLs();
+      return tree;
+    },
+    exportState: () => readBuffer(stateExport()),
+    importState: (state) => {
+      withPayload(JSON.parse(state), (ptr, length) => {
+        stateImport(ptr, length);
+        return 0;
+      });
+    }
+  };
+}
+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;
+  const pending = fetch(url).then((response) => {
+    if (!response.ok) {
+      throw new Error(`swift artifact ${url} answered ${response.status}`);
+    }
+    return response.arrayBuffer();
+  }).then((bytes) => WebAssembly.compile(bytes));
+  compiledModules.set(url, pending);
+  return pending;
+}
+var HIERARCHICAL = /* @__PURE__ */ new Map([
+  ["label", "primary"],
+  ["secondaryLabel", "secondary"]
+]);
+function withAlpha(color, alpha) {
+  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(color);
+  if (hex) {
+    const digits = hex[1];
+    const full = digits.length === 3 ? digits.split("").map((digit) => digit + digit).join("") : digits;
+    const value = Number.parseInt(full, 16);
+    return `rgba(${value >> 16 & 255},${value >> 8 & 255},${value & 255},${alpha})`;
+  }
+  const rgba = /^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d.]+)\s*\)$/.exec(color);
+  if (rgba) {
+    return `rgba(${rgba[1]},${rgba[2]},${rgba[3]},${Number(rgba[4]) * alpha})`;
+  }
+  throw new Error(`swift color ${color} cannot take opacity ${alpha}`);
+}
+function splitColor(value) {
+  const at = value.lastIndexOf("@");
+  return at === -1 ? { name: value, alpha: 1 } : { name: value.slice(0, at), alpha: Number(value.slice(at + 1)) };
+}
+function resolveColor(value) {
+  const { name, alpha } = splitColor(value);
+  const resolved = (0, import_react_native.PlatformColor)(name);
+  if (alpha === 1) return resolved;
+  if (typeof resolved === "string") return withAlpha(resolved, alpha);
+  if (isRecord(resolved) && isRecord(resolved.dynamic)) {
+    const variants = {};
+    for (const [scheme, variant] of Object.entries(resolved.dynamic)) {
+      if (typeof variant !== "string") {
+        throw new Error(`swift color ${name} has a non-string ${scheme} variant`);
+      }
+      variants[scheme] = withAlpha(variant, alpha);
+    }
+    return { dynamic: variants };
+  }
+  throw new Error(`swift color ${name} cannot take opacity ${alpha}`);
+}
+function resolveModifier(modifier) {
+  const color = modifier.color;
+  if (typeof color !== "string") {
+    const glass = modifier.glass;
+    if (modifier.$type === "glassEffect" && isRecord(glass) && typeof glass.tint === "string") {
+      return { ...modifier, glass: { ...glass, tint: resolveColor(glass.tint) } };
+    }
+    return modifier;
+  }
+  const { name, alpha } = splitColor(color);
+  const level = modifier.$type === "foregroundStyle" ? HIERARCHICAL.get(name) : void 0;
+  if (level !== void 0 && alpha === 1) {
+    return {
+      $type: "foregroundStyle",
+      styleType: "hierarchical",
+      hierarchicalStyle: level
+    };
+  }
+  return { ...modifier, color: resolveColor(color) };
+}
+var SwiftResourcesContext = (0, import_react.createContext)(void 0);
+function SwiftImage(props) {
+  const table = (0, import_react.useContext)(SwiftResourcesContext);
+  const { source, ...rest } = props ?? {};
+  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: resolved }
+  });
+}
+var NODE_COMPONENTS = {
+  Alert: SwiftAlert,
+  BottomSheet: import_ui.BottomSheet,
+  Button: import_ui.Button,
+  Capsule: import_ui.Capsule,
+  Circle: import_ui.Circle,
+  ConfirmationDialog: import_ui.ConfirmationDialog,
+  ContextMenu: import_ui.ContextMenu,
+  DatePicker: import_ui.DatePicker,
+  Divider: import_ui.Divider,
+  Ellipse: import_ui.Ellipse,
+  Form: import_ui.Form,
+  GeometryReader: import_ui.GeometryReader,
+  GlassEffectContainer: import_ui.GlassEffectContainer,
+  Group: import_ui.Group,
+  HStack: import_ui.HStack,
+  Image: SwiftImage,
+  Label: import_ui.Label,
+  LazyVStack: import_ui.LazyVStack,
+  LinearGradient: import_ui.LinearGradient,
+  List: import_ui.List,
+  Menu: import_ui.Menu,
+  Path: import_ui.Path,
+  Picker: import_ui.Picker,
+  ProgressView: import_ui.ProgressView,
+  Rectangle: import_ui.Rectangle,
+  RoundedRectangle: import_ui.RoundedRectangle,
+  ScrollView: import_ui.ScrollView,
+  Section: import_ui.Section,
+  SecureField: import_ui.SecureField,
+  Slider: import_ui.Slider,
+  Spacer: import_ui.Spacer,
+  Stepper: import_ui.Stepper,
+  SwipeActions: import_ui.SwipeActions,
+  Text: import_ui.Text,
+  TextField: import_ui.TextField,
+  Toggle: import_ui.Toggle,
+  Tab: SwiftTabScene,
+  TabView: SwiftTabView,
+  VStack: import_ui.VStack,
+  ZStack: import_ui.ZStack
+};
+var TEXT_STYLE_SIZES = /* @__PURE__ */ new Map([
+  ["largeTitle", 34],
+  ["title", 28],
+  ["title2", 22],
+  ["title3", 20],
+  ["headline", 17],
+  ["subheadline", 15],
+  ["body", 17],
+  ["callout", 16],
+  ["footnote", 13],
+  ["caption", 12],
+  ["caption2", 11]
+]);
+var FONT_WEIGHTS = /* @__PURE__ */ new Map([
+  ["ultraLight", "100"],
+  ["thin", "200"],
+  ["light", "300"],
+  ["regular", "400"],
+  ["medium", "500"],
+  ["semibold", "600"],
+  ["bold", "700"],
+  ["heavy", "800"],
+  ["black", "900"]
+]);
+function fontModifier(modifiers) {
+  return modifiers?.find((modifier) => modifier.$type === "font");
+}
+function fontStyle(font) {
+  if (!font) return void 0;
+  const style = {};
+  if (typeof font.size === "number") style.fontSize = font.size;
+  else if (typeof font.style === "string") {
+    const size = TEXT_STYLE_SIZES.get(font.style);
+    if (size === void 0) throw new Error(`swift font style ${font.style} has no size`);
+    style.fontSize = size;
+  }
+  if (typeof font.weight === "string") {
+    const weight = FONT_WEIGHTS.get(font.weight);
+    if (weight === void 0)
+      throw new Error(`swift font weight ${font.weight} has no value`);
+    style.fontWeight = weight;
+  }
+  return style;
+}
+function sameValue(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let index = 0; index < a.length; index += 1) {
+      if (!sameValue(a[index], b[index])) return false;
+    }
+    return true;
+  }
+  if (isRecord(a) && isRecord(b)) {
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) return false;
+    for (const key of keys) {
+      if (!sameValue(a[key], b[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function sameNode(a, b) {
+  if (a === b) return true;
+  if (a.t !== b.t || a.id !== b.id) return false;
+  if (!sameValue(a.p, b.p) || !sameValue(a.m, b.m) || !sameValue(a.h, b.h)) return false;
+  const left = a.c ?? [];
+  const right = b.c ?? [];
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    if (!sameNode(left[index], right[index])) return false;
+  }
+  return true;
+}
+function handlerId(node, name) {
+  return node.h?.[name];
+}
+function pressProps(node, deliver) {
+  const presses = [];
+  for (const name of ["onPress", "onTap"]) {
+    const id = handlerId(node, name);
+    if (id !== void 0) presses.push(id);
+  }
+  if (presses.length === 0) return {};
+  return {
+    onPress: () => {
+      for (const id of presses) deliver(id, null);
+    }
+  };
+}
+function SwiftTabScene({ children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+}
+function SwiftTabView({
+  tabs,
+  selection,
+  onSelect,
+  modifiers,
+  children
+}) {
+  const scenes = import_react.Children.toArray(children);
+  const routes = tabs.map((tab, index2) => ({
+    key: tab.testID,
+    name: tab.title ?? `tab-${index2}`,
+    title: tab.title,
+    sfSymbol: tab.systemImage,
+    testID: tab.testID
+  }));
+  const index = selection >= 0 && selection < routes.length ? selection : 0;
+  (0, import_react.useEffect)(() => {
+    if (selection !== index) onSelect?.(index);
+  }, [selection, index, onSelect]);
+  const bar = (0, import_react.createElement)(import_react_native_bottom_tabs.default, {
+    navigationState: { index, routes },
+    renderScene: ({ route }) => scenes[routes.findIndex((candidate) => candidate.key === route.key)],
+    onIndexChange: (next) => onSelect?.(next),
+    getLabelText: ({ route }) => route.title ?? route.key,
+    getIcon: ({ route }) => route.sfSymbol ? { sfSymbol: route.sfSymbol } : void 0,
+    getTestID: ({ route }) => route.testID
+  });
+  return (0, import_react.createElement)(
+    import_ui.VStack,
+    {
+      ...modifiers?.length ? { modifiers } : {},
+      style: {
+        alignSelf: "stretch",
+        alignItems: "stretch",
+        flexGrow: 1,
+        flexShrink: 1,
+        flexBasis: "auto"
+      }
+    },
+    bar
+  );
+}
+function SwiftAlert({
+  title,
+  message,
+  buttons,
+  onButtonPress,
+  onDismiss
+}) {
+  const latest = (0, import_react.useRef)({ title, message, buttons, onButtonPress, onDismiss });
+  (0, import_react.useEffect)(() => {
+    latest.current = { title, message, buttons, onButtonPress, onDismiss };
+  });
+  (0, import_react.useEffect)(() => {
+    const handle = (0, import_runtime.getNativeAlerts)().show(
+      latest.current.title,
+      latest.current.message,
+      latest.current.buttons.map((button, index) => ({
+        text: button.text,
+        style: button.role === "destructive" ? "destructive" : button.role === "cancel" ? "cancel" : "default",
+        // the tapped action runs its swift closure and clears isPresented,
+        // which is the order the system alert uses on the way out: the action
+        // body is the last thing that runs with the alert still up. the
+        // handlers come off the ref at tap time, not from this render.
+        onPress: () => {
+          latest.current.onButtonPress?.(index);
+          latest.current.onDismiss?.();
+        }
+      }))
+    );
+    return () => {
+      (0, import_runtime.getNativeAlerts)().dismiss(handle);
+    };
+  }, []);
+  return null;
+}
+function readAlertButtons(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((entry) => {
+    if (!isRecord(entry)) return {};
+    return {
+      ...typeof entry.text === "string" ? { text: entry.text } : {},
+      ...typeof entry.role === "string" ? { role: entry.role } : {}
+    };
+  });
+}
+function nodeProps(node, deliver) {
+  const props = node.p ?? {};
+  switch (node.t) {
+    case "Text": {
+      const style = fontStyle(fontModifier(node.m));
+      return {
+        children: typeof props.children === "string" ? props.children : "",
+        ...style ? { style } : {},
+        ...pressProps(node, deliver)
+      };
+    }
+    case "Image": {
+      const font = fontModifier(node.m);
+      const size = typeof font?.size === "number" ? font.size : void 0;
+      return {
+        ...typeof props.systemName === "string" ? { systemName: props.systemName } : {},
+        // a bundle asset name rides as the kit image source; the kit paints
+        // 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 } : {},
+        ...size === void 0 ? {} : { size },
+        ...pressProps(node, deliver)
+      };
+    }
+    case "Toggle": {
+      const onValueChange = handlerId(node, "onValueChange");
+      return {
+        isOn: props.value === true,
+        ...onValueChange === void 0 ? {} : { onIsOnChange: (value) => deliver(onValueChange, value) },
+        // the gesture replaces the row's own press (a label tap runs it and
+        // does not toggle); the switch keeps toggling through onValueChange.
+        ...pressProps(node, deliver)
+      };
+    }
+    case "TextField": {
+      const onChangeText = handlerId(node, "onChangeText");
+      return {
+        ...typeof props.placeholder === "string" ? { placeholder: props.placeholder } : {},
+        ...typeof props.defaultValue === "string" ? { defaultValue: props.defaultValue } : {},
+        ...onChangeText === void 0 ? {} : { onChangeText: (value) => deliver(onChangeText, value) }
+      };
+    }
+    case "Slider": {
+      const onValueChange = handlerId(node, "onValueChange");
+      return {
+        value: typeof props.value === "number" ? props.value : 0,
+        min: typeof props.min === "number" ? props.min : 0,
+        max: typeof props.max === "number" ? props.max : 1,
+        ...onValueChange === void 0 ? {} : { onValueChange: (value) => deliver(onValueChange, value) },
+        // a tap runs the gesture and leaves the value alone: only a drag
+        // moves it, so the gesture rides onPress beside the drag handler.
+        ...pressProps(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) => {
+        const tabProps = tab.p ?? {};
+        return {
+          ...typeof tabProps.title === "string" ? { title: tabProps.title } : {},
+          ...typeof tabProps.systemImage === "string" ? { systemImage: tabProps.systemImage } : {},
+          ...typeof tabProps.role === "string" ? { role: tabProps.role } : {},
+          testID: `swift-tab-${index}`
+        };
+      });
+      return {
+        tabs,
+        selection: typeof props.selection === "number" ? props.selection : 0,
+        ...onSelect === void 0 ? {} : { onSelect: (index) => deliver(onSelect, index) }
+      };
+    }
+    case "BottomSheet": {
+      const onDismiss = handlerId(node, "onDismiss");
+      const detents = (node.c ?? []).flatMap((child) => nodeModifiers(child) ?? []).filter((modifier) => modifier.$type === "presentationDetents");
+      return {
+        isOpened: props.isOpened === true,
+        ...detents.length === 0 ? {} : { modifiers: detents },
+        ...onDismiss === void 0 ? {} : { onDismiss: () => deliver(onDismiss, null) }
+      };
+    }
+    case "ConfirmationDialog": {
+      return { isPresented: props.isPresented === true };
+    }
+    case "Alert": {
+      const onButtonPress = handlerId(node, "onButtonPress");
+      const onDismiss = handlerId(node, "onDismiss");
+      return {
+        title: typeof props.title === "string" ? props.title : "",
+        ...typeof props.message === "string" ? { message: props.message } : {},
+        buttons: readAlertButtons(props.buttons),
+        ...onButtonPress === void 0 ? {} : { onButtonPress: (index) => deliver(onButtonPress, index) },
+        ...onDismiss === void 0 ? {} : { onDismiss: () => deliver(onDismiss, null) }
+      };
+    }
+    case "SecureField": {
+      const onChangeText = handlerId(node, "onChangeText");
+      return {
+        ...typeof props.placeholder === "string" ? { placeholder: props.placeholder } : {},
+        ...typeof props.prompt === "string" ? { prompt: props.prompt } : {},
+        ...typeof props.defaultValue === "string" ? { defaultValue: props.defaultValue } : {},
+        ...onChangeText === void 0 ? {} : { onChangeText: (value) => deliver(onChangeText, value) }
+      };
+    }
+    case "Picker": {
+      const onSelectionChange = handlerId(node, "onSelectionChange");
+      return {
+        ...typeof props.title === "string" ? { label: props.title } : {},
+        ...props.selection === void 0 ? {} : { selection: props.selection },
+        ...onSelectionChange === void 0 ? {} : {
+          onSelectionChange: (value) => deliver(onSelectionChange, value)
+        }
+      };
+    }
+    case "DatePicker": {
+      return {
+        ...typeof props.title === "string" ? { label: props.title } : {},
+        // the wire carries epoch seconds; the kit takes a Date and formats it
+        ...typeof props.value === "number" ? { value: new Date(props.value * 1e3) } : {},
+        ...Array.isArray(props.components) ? { components: props.components } : {}
+      };
+    }
+    case "GlassEffectContainer":
+      return {};
+    case "ProgressView":
+      return {
+        ...typeof props.title === "string" ? { label: props.title } : {},
+        ...typeof props.value === "number" || props.value === null ? { value: props.value } : {},
+        ...typeof props.total === "number" ? { total: props.total } : {}
+      };
+    default:
+      return { ...props, ...pressProps(node, deliver) };
+  }
+}
+function numberProp(node, name) {
+  const value = node.p?.[name];
+  return typeof value === "number" ? value : 0;
+}
+function menuItemLabel(node) {
+  const [only] = node.c ?? [];
+  if (node.t !== "Button" || node.c?.length !== 1 || !only) return void 0;
+  if (only.t === "Text" && typeof only.p?.children === "string") {
+    return { label: only.p.children };
+  }
+  if (only.t === "Label" && typeof only.p?.title === "string" && (only.p?.systemImage === void 0 || typeof only.p?.systemImage === "string")) {
+    return {
+      label: only.p.title,
+      ...typeof only.p?.systemImage === "string" ? { systemImage: only.p.systemImage } : {}
+    };
+  }
+  return void 0;
+}
+function renderMenuItem(node, deliver, cache) {
+  const item = menuItemLabel(node);
+  if (item !== void 0) {
+    const modifiers = nodeModifiers(node);
+    return (0, import_react.createElement)(import_ui.Button, {
+      key: node.id,
+      ...item,
+      ...modifiers === void 0 ? {} : { modifiers },
+      ...pressProps(node, deliver)
+    });
+  }
+  return renderNode(node, deliver, cache);
+}
+function renderMenu(node, deliver, cache) {
+  const labelCount = numberProp(node, "labelCount");
+  const kids = node.c ?? [];
+  const labels = kids.slice(0, labelCount);
+  const items = kids.slice(labelCount);
+  const [only] = labels;
+  const onlyText = labels.length === 1 && only.t === "Text" && typeof only.p?.children === "string" ? only.p.children : void 0;
+  const onlyLabel = labels.length === 1 && only.t === "Label" && typeof only.p?.title === "string" && (only.p?.systemImage === void 0 || typeof only.p?.systemImage === "string") ? only : void 0;
+  const label = onlyText !== void 0 || onlyLabel !== void 0 ? void 0 : (0, import_react.createElement)(
+    import_react.Fragment,
+    null,
+    ...labels.map((child) => renderNode(child, deliver, cache))
+  );
+  const labelModifiers = labels.length === 1 ? nodeModifiers(only) : void 0;
+  const modifiers = nodeModifiers(node);
+  const combined = [...labelModifiers ?? [], ...modifiers ?? []];
+  return (0, import_react.createElement)(
+    import_ui.Menu,
+    {
+      key: node.id,
+      ...combined.length > 0 ? { modifiers: combined } : {},
+      ...onlyText !== void 0 ? { label: onlyText } : {},
+      ...onlyLabel !== void 0 ? {
+        label: onlyLabel.p?.title,
+        ...typeof onlyLabel.p?.systemImage === "string" ? { systemImage: onlyLabel.p.systemImage } : {}
+      } : {},
+      ...label === void 0 ? {} : { label }
+    },
+    ...items.map((child) => renderMenuItem(child, deliver))
+  );
+}
+function renderContextMenu(node, deliver, cache) {
+  const kids = node.c ?? [];
+  const contentCount = numberProp(node, "contentCount");
+  const itemCount = numberProp(node, "itemCount");
+  const content = kids.slice(0, contentCount);
+  const items = kids.slice(contentCount, contentCount + itemCount);
+  const preview = kids.slice(contentCount + itemCount);
+  const modifiers = nodeModifiers(node);
+  return (0, import_react.createElement)(
+    import_ui.ContextMenu,
+    {
+      key: node.id,
+      ...modifiers === void 0 ? {} : { modifiers }
+    },
+    (0, import_react.createElement)(
+      import_ui.Trigger,
+      { key: `${node.id}/trigger` },
+      ...content.map((child) => renderNode(child, deliver, cache))
+    ),
+    (0, import_react.createElement)(
+      import_ui.Items,
+      { key: `${node.id}/items` },
+      ...items.map((child) => renderMenuItem(child, deliver))
+    ),
+    ...preview.length > 0 ? [
+      (0, import_react.createElement)(
+        import_ui.Preview,
+        { key: `${node.id}/preview` },
+        ...preview.map((child) => renderNode(child, deliver, cache))
+      )
+    ] : []
+  );
+}
+function renderSwipeActions(node, deliver, cache) {
+  const kids = node.c ?? [];
+  const content = kids.slice(0, numberProp(node, "contentCount"));
+  const actions = kids.slice(numberProp(node, "contentCount"));
+  const modifiers = nodeModifiers(node);
+  const { Actions } = import_ui.SwipeActions;
+  return (0, import_react.createElement)(
+    import_ui.SwipeActions,
+    {
+      key: node.id,
+      ...modifiers === void 0 ? {} : { modifiers }
+    },
+    ...content.map((child) => renderNode(child, deliver, cache)),
+    ...actions.length > 0 ? [
+      (0, import_react.createElement)(
+        Actions,
+        {
+          key: `${node.id}/actions`,
+          edge: node.p?.edge === "leading" ? "leading" : "trailing",
+          ...typeof node.p?.allowsFullSwipe === "boolean" ? { allowsFullSwipe: node.p.allowsFullSwipe } : {}
+        },
+        ...actions.map((child) => renderNode(child, deliver, cache))
+      )
+    ] : []
+  );
+}
+function ClosureStepper({
+  deliver,
+  onIncrement,
+  onDecrement,
+  ...rest
+}) {
+  const last = (0, import_react.useRef)(0);
+  return (0, import_react.createElement)(import_ui.Stepper, {
+    ...rest,
+    onValueChange: (next) => {
+      if (next > last.current && onIncrement !== void 0) {
+        deliver(onIncrement, null);
+      } else if (next < last.current && onDecrement !== void 0) {
+        deliver(onDecrement, null);
+      }
+      last.current = next;
+    }
+  });
+}
+function renderStepper(node, deliver, cache) {
+  const kids = node.c ?? [];
+  const label = kids.length === 0 ? void 0 : (0, import_react.createElement)(
+    import_react.Fragment,
+    null,
+    ...kids.map((child) => renderNode(child, deliver, cache))
+  );
+  const modifiers = nodeModifiers(node);
+  const shared = {
+    key: node.id,
+    ...modifiers === void 0 ? {} : { modifiers },
+    ...label === void 0 ? {} : { label },
+    ...typeof node.p?.min === "number" ? { min: node.p.min } : {},
+    ...typeof node.p?.max === "number" ? { max: node.p.max } : {},
+    ...typeof node.p?.step === "number" ? { step: node.p.step } : {}
+  };
+  const onValueChange = handlerId(node, "onValueChange");
+  if (onValueChange !== void 0) {
+    return (0, import_react.createElement)(import_ui.Stepper, {
+      ...shared,
+      ...typeof node.p?.value === "number" ? { value: node.p.value } : {},
+      onValueChange: (value) => deliver(onValueChange, value)
+    });
+  }
+  return (0, import_react.createElement)(ClosureStepper, {
+    ...shared,
+    deliver,
+    ...handlerId(node, "onIncrement") === void 0 ? {} : { onIncrement: handlerId(node, "onIncrement") },
+    ...handlerId(node, "onDecrement") === void 0 ? {} : { onDecrement: handlerId(node, "onDecrement") }
+  });
+}
+function buttonModifier(modifier) {
+  if (modifier.$type === "glassEffect") {
+    const glass = modifier.glass;
+    const variant = isRecord(glass) && typeof glass.variant === "string" ? glass.variant : "regular";
+    return variant === "identity" ? modifier : { $type: "buttonStyle", style: "glass" };
+  }
+  if (modifier.$type === "foregroundStyle" && modifier.color !== void 0) {
+    return { $type: "tint", color: modifier.color };
+  }
+  return modifier;
+}
+function nodeModifiers(node) {
+  const resolved = node.m?.map(resolveModifier);
+  if (node.t !== "Button") return resolved;
+  return resolved?.map(buttonModifier);
+}
+function dialogChildren(node, deliver) {
+  const children = node.c?.map((child) => renderNode(child, deliver));
+  const props = node.p ?? {};
+  if (props.showsTitle !== true || typeof props.title !== "string") return children;
+  const title = (0, import_react.createElement)(import_ui.Text, { key: `${node.id}/title`, children: props.title });
+  return [title, ...children ?? []];
+}
+var Stack = (0, import_native_stack.createNativeStackNavigator)();
+var NAVIGATOR_FILL = { flex: 1, alignSelf: "stretch" };
+function readNodes(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(readNode);
+}
+function hasPrefix(names, of) {
+  return names.every((name, index) => of[index] === name);
+}
+function sameNames(a, b) {
+  return a.length === b.length && a.every((name, index) => b[index] === name);
+}
+function commonPrefixLength(a, b) {
+  let length = 0;
+  while (length < a.length && length < b.length && a[length] === b[length]) length++;
+  return length;
+}
+function reconcilePlan(names, desired) {
+  const common = commonPrefixLength(names, desired);
+  if (common === names.length && common === desired.length) return { kind: "in-step" };
+  if (common === names.length) return { kind: "push" };
+  if (common === desired.length) return { kind: "pop" };
+  const top = desired[desired.length - 1];
+  return { kind: "replace", replaceAnimation: names.includes(top) ? "pop" : "push" };
+}
+function resolveLargeTitles(modes) {
+  let previous = true;
+  return modes.map((mode) => {
+    const large = mode === "inline" ? false : mode === "large" ? true : previous;
+    previous = large;
+    return large;
+  });
+}
+function screenOptions(node, deliver, largeTitle, replaceAnimation) {
+  const props = node.p ?? {};
+  const options = {
+    title: typeof props.title === "string" ? props.title : "",
+    headerLargeTitleEnabled: largeTitle
+  };
+  if (replaceAnimation !== void 0) options.animationTypeForReplace = replaceAnimation;
+  const leading = readNodes(props.leading);
+  const trailing = readNodes(props.trailing);
+  const principal = readNodes(props.principal);
+  const render = (nodes) => () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: nodes.map((child) => renderNode(child, deliver)) });
+  if (leading.length > 0) {
+    options.headerLeft = render(leading);
+    options.headerBackVisible = true;
+  }
+  if (trailing.length > 0) options.headerRight = render(trailing);
+  if (principal.length > 0) options.headerTitle = render(principal);
+  return options;
+}
+function SwiftScreen({
+  node,
+  navigation,
+  deliver,
+  report
+}) {
+  const routes = (0, import_native.useNavigationState)(
+    (state) => state.routes.map((route) => route.name).join("\0")
+  );
+  (0, import_react.useEffect)(() => {
+    report(navigation, routes === "" ? [] : routes.split("\0"));
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: node.c?.map((child) => renderNode(child, deliver)) });
+}
+function NavigationStackHost({ node, deliver }) {
+  const screens = (node.c ?? []).filter((child) => child.t === "NavigationScreen");
+  const desired = screens.map((screen) => screen.id);
+  const largeTitles = resolveLargeTitles(
+    screens.map((screen) => {
+      const mode = screen.p?.titleDisplayMode;
+      return typeof mode === "string" ? mode : void 0;
+    })
+  );
+  const onPop = node.h?.onPop;
+  const reportRef = (0, import_react.useRef)(null);
+  const reportedRef = (0, import_react.useRef)([]);
+  const expectedRef = (0, import_react.useRef)(null);
+  const syncedRef = (0, import_react.useRef)(null);
+  const [, rerender] = (0, import_react.useReducer)((count) => count + 1, 0);
+  const report = (0, import_react.useCallback)((navigation, names) => {
+    const previous = reportRef.current;
+    reportRef.current = { navigation, names };
+    if (previous && sameNames(previous.names, names)) return;
+    rerender();
+  }, []);
+  const reported = reportRef.current?.names ?? [];
+  const plan = reportRef.current ? reconcilePlan(reported, desired) : null;
+  const replaceTop = plan?.kind === "replace" ? desired[desired.length - 1] : void 0;
+  (0, import_react.useEffect)(() => {
+    const current = reportRef.current;
+    if (!current) return;
+    const names = current.names;
+    const previous = reportedRef.current;
+    const isReport = !sameNames(previous, names);
+    if (isReport) reportedRef.current = names;
+    const expected = expectedRef.current;
+    if (expected) {
+      if (sameNames(expected, names)) expectedRef.current = null;
+      else if (!isReport) return;
+      else expectedRef.current = null;
+    }
+    const dropped = previous.slice(names.length);
+    const settled = syncedRef.current;
+    const navigatorPopped = isReport && dropped.length > 0 && settled !== null && sameNames(settled, desired) && hasPrefix(names, desired) && hasPrefix(desired.slice(names.length), dropped);
+    if (navigatorPopped && onPop !== void 0) {
+      deliver(onPop, { count: dropped.length });
+      return;
+    }
+    const next = reconcilePlan(names, desired);
+    if (next.kind === "in-step") {
+      expectedRef.current = null;
+      syncedRef.current = desired;
+      return;
+    }
+    expectedRef.current = desired;
+    if (next.kind === "push") {
+      for (const name of desired.slice(names.length)) current.navigation.push(name);
+      return;
+    }
+    if (next.kind === "pop") {
+      current.navigation.pop(names.length - desired.length);
+      return;
+    }
+    current.navigation.reset({
+      index: Math.max(0, desired.length - 1),
+      routes: desired.map((name) => ({ name }))
+    });
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Stack.Navigator, { initialRouteName: desired[0], children: screens.map((screen, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    Stack.Screen,
+    {
+      name: screen.id,
+      options: screenOptions(
+        screen,
+        deliver,
+        largeTitles[index],
+        screen.id === replaceTop ? plan?.kind === "replace" ? plan.replaceAnimation : void 0 : void 0
+      ),
+      children: (props) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        SwiftScreen,
+        {
+          node: screen,
+          navigation: props.navigation,
+          deliver,
+          report
+        }
+      )
+    },
+    screen.id
+  )) });
+}
+var REGULAR_WIDTH = 768;
+function SplitViewHost({
+  node,
+  deliver,
+  cache
+}) {
+  const { width } = (0, import_react_native.useWindowDimensions)();
+  const screens = (node.c ?? []).filter((child) => child.t === "NavigationScreen");
+  if (width < REGULAR_WIDTH) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.View, { style: NAVIGATOR_FILL, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NavigationStackHost, { node, deliver }) });
+  }
+  const sidebar = screens[0];
+  const pushed = screens.slice(1);
+  const detailProp = node.p?.detail;
+  const detail = isRecord(detailProp) && detailProp.t === "SplitDetail" ? readNodes(detailProp.c) : [];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native.View, { style: { flex: 1, flexDirection: "row", alignSelf: "stretch" }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.View, { style: { width: 320 }, children: sidebar ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NavigationStackHost, { node: { ...node, c: [sidebar] }, deliver }) : null }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.View, { style: { flex: 1 }, children: pushed.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NavigationStackHost, { node: { ...node, c: pushed }, deliver }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: detail.map((child) => renderNode(child, deliver, cache)) }) })
+  ] });
+}
+function SwiftAppear({
+  node,
+  deliver,
+  children
+}) {
+  const onAppear = handlerId(node, "onAppear");
+  const onDisappear = handlerId(node, "onDisappear");
+  (0, import_react.useEffect)(() => {
+    if (onAppear !== void 0) deliver(onAppear, null);
+    return () => {
+      if (onDisappear !== void 0) deliver(onDisappear, null);
+    };
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+}
+function renderNode(node, deliver, cache) {
+  const cached = cache?.entries.get(node.id);
+  if (cached && sameNode(cached.node, node)) return cached.element;
+  const built = buildNode(node, deliver, cache);
+  const element = node.h?.onAppear !== void 0 || node.h?.onDisappear !== void 0 ? (0, import_react.createElement)(SwiftAppear, { key: node.id, node, deliver }, built) : built;
+  cache?.entries.set(node.id, { node, element });
+  return element;
+}
+function buildNode(node, deliver, cache) {
+  if (node.t === "Menu") return renderMenu(node, deliver, cache);
+  if (node.t === "ContextMenu") return renderContextMenu(node, deliver, cache);
+  if (node.t === "SwipeActions") return renderSwipeActions(node, deliver, cache);
+  if (node.t === "Stepper") return renderStepper(node, deliver, cache);
+  if (node.t === "NavigationStack") {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.View, { style: NAVIGATOR_FILL, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NavigationStackHost, { node, deliver }) }, node.id);
+  }
+  if (node.t === "NavigationSplitView") {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SplitViewHost, { node, deliver, cache }, node.id);
+  }
+  if (node.t === "NavigationLink") {
+    return (0, import_react.createElement)(
+      import_ui.Button,
+      {
+        key: node.id,
+        ...pressProps(node, deliver)
+      },
+      ...(node.c ?? []).map((child) => renderNode(child, deliver, cache))
+    );
+  }
+  const component = NODE_COMPONENTS[node.t];
+  if (!component) throw new Error(`swift view ${node.t} has no rnx kit component`);
+  const modifiers = nodeModifiers(node);
+  const children = node.t === "ConfirmationDialog" ? dialogChildren(node, deliver) : node.c?.map((child) => renderNode(child, deliver));
+  return (0, import_react.createElement)(
+    component,
+    {
+      key: node.id,
+      ...modifiers === void 0 ? {} : { modifiers },
+      ...nodeProps(node, deliver)
+    },
+    ...children ?? []
+  );
+}
+function SwiftTree({
+  tree,
+  deliver,
+  cache,
+  resources
+}) {
+  return (
+    // 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, backgroundColor: (0, import_react_native.PlatformColor)("systemBackground") },
+        ignoreSafeArea: tree.some(
+          (node) => node.t === "NavigationStack" || node.t === "NavigationSplitView"
+        ),
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_native.NavigationIndependentTree, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_native.NavigationContainer, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SwiftResourcesContext.Provider, { value: resources, children: tree.map((node) => renderNode(node, deliver, cache)) }) }) })
+      }
+    )
+  );
+}
+var ROOT_KEY = "__rnx_swift_roots__";
+function rootRegistry() {
+  const existing = Reflect.get(globalThis, ROOT_KEY);
+  if (existing instanceof Map) return existing;
+  const created = /* @__PURE__ */ new Map();
+  Reflect.set(globalThis, ROOT_KEY, created);
+  return created;
+}
+function slotFor(rootId, mountTree) {
+  const registry = rootRegistry();
+  const existing = registry.get(rootId);
+  if (existing) return existing;
+  const created = { root: createRoot(mountTree) };
+  registry.set(rootId, created);
+  return created;
+}
+function createRoot(mountTree) {
+  let instance = null;
+  let source = null;
+  let refresh;
+  let state = { tree: null, isView: false, error: null };
+  let swap = Promise.resolve();
+  const listeners = /* @__PURE__ */ new Set();
+  const cache = { entries: /* @__PURE__ */ new Map() };
+  const publish = (next) => {
+    state = next;
+    for (const listener of listeners) listener();
+  };
+  const apply = async (options, props) => {
+    const carried = instance?.exportState() ?? null;
+    const created = instantiate(
+      await compile(options.url),
+      decodeBundle(options.url, options.bundleFiles)
+    );
+    if (carried !== null) created.importState(carried);
+    if (source !== options) return;
+    instance = created;
+    const mounted = mountTree(created, props);
+    publish({ tree: mounted.tree, isView: mounted.isView, error: null });
+  };
+  const component = function SwiftRoot() {
+    const rendered = (0, import_react.useSyncExternalStore)(
+      (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+      () => state
+    );
+    if (rendered.error) throw rendered.error;
+    if (!rendered.tree) return null;
+    const deliver = (handlerId2, payload) => {
+      if (!instance) throw new Error("swift app received an event before it mounted");
+      publish({
+        tree: instance.deliver(handlerId2, payload),
+        isView: rendered.isView,
+        error: null
+      });
+    };
+    const resources = source?.resources;
+    if (rendered.isView)
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SwiftResourcesContext.Provider, { value: resources, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: rendered.tree.map((node) => renderNode(node, deliver, cache)) }) });
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      SwiftTree,
+      {
+        tree: rendered.tree,
+        deliver,
+        cache,
+        resources
+      }
+    );
+  };
+  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) || JSON.stringify(source.bundleFiles ?? null) !== JSON.stringify(options.bundleFiles ?? null) || refreshKey !== void 0 && refreshKey !== refresh;
+      if (changed) {
+        source = options;
+        refresh = refreshKey;
+        const next = props ?? {};
+        swap = swap.then(
+          () => apply(options, next),
+          () => apply(options, next)
+        );
+        swap.catch((error) => {
+          publish({
+            tree: null,
+            isView: false,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        });
+      }
+      return component;
+    }
+  };
+}
+function propsSignature(props) {
+  try {
+    return JSON.stringify(props, (_key, value) => {
+      if (typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
+        throw new Error(`swift view props must be json; found ${typeof value}`);
+      }
+      return value;
+    }) ?? "null";
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("swift view props"))
+      throw error;
+    throw new Error(
+      `swift view props must be json: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function createSwiftEntry(options) {
+  const rootId = options.rootId ?? "root";
+  const slot = slotFor(
+    rootId,
+    (instance, props) => instance.hasView() ? { tree: instance.mountView(props), isView: true } : { tree: instance.mount(), isView: false }
+  );
+  return function SwiftEntry(props) {
+    if (props.children !== void 0) {
+      throw new Error("swift entries take data props, not children");
+    }
+    const component = slot.root.use(options, propsSignature(props), props);
+    return (0, import_react.createElement)(component);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSwiftEntry
+});