rnxsim 0.1.519 → 0.1.521

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.519 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.521 | (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;
@@ -762,12 +762,20 @@ var import_node_fs3 = __toESM(require("node:fs"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path4 = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
+
+// ../sootsim-swift/toolchain.json
+var toolchain_default = {
+  release: "swift-6.3-RELEASE",
+  wasmSdkChecksum: "9fa4016ee632c7e9e906608ec3b55cf13dfc4dff44e47574c5af58064dc33fd9"
+};
+
+// src/vite-plugin-swift.ts
 var run = (0, import_node_util.promisify)(import_node_child_process2.execFile);
 var TOOLCHAIN_BIN = import_node_path4.default.join(
   import_node_os2.default.homedir(),
-  "Library/Developer/Toolchains/swift-6.2-RELEASE.xctoolchain/usr/bin"
+  `Library/Developer/Toolchains/${toolchain_default.release}.xctoolchain/usr/bin`
 );
-var WASM_SDK = "swift-6.2-RELEASE_wasm";
+var WASM_SDK = `${toolchain_default.release}_wasm`;
 var WASM_TRIPLE = "wasm32-unknown-wasip1";
 var ARTIFACT_PATH = "/__rnx/swift/";
 var VIRTUAL_PREFIX = "\0rnx-swift:";
@@ -780,30 +788,50 @@ function projectFor(packagePath) {
   projects.set(packagePath, created);
   return created;
 }
-function rootFor(file) {
-  return devServer?.config.root ?? import_node_path4.default.dirname(file);
-}
-function sourceFiles(packagePath) {
+function sourceFiles(root) {
   const found = [];
   const walk = (dir) => {
     for (const entry of import_node_fs3.default.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
       const full = import_node_path4.default.join(dir, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else if (entry.name.endsWith(".swift")) found.push(full);
+      if (entry.isDirectory()) {
+        if (full !== root && import_node_fs3.default.existsSync(import_node_path4.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else if (entry.name.endsWith(".swift")) found.push(full);
     }
   };
-  walk(packagePath);
+  walk(root);
   return found;
 }
+function linkedModuleRoots(packagePath) {
+  let manifest;
+  try {
+    manifest = import_node_fs3.default.readFileSync(import_node_path4.default.join(packagePath, "Package.swift"), "utf8");
+  } catch {
+    return [];
+  }
+  const roots = /* @__PURE__ */ new Set();
+  const dependency = /\.package\(\s*path:\s*"([^"]+)"\s*\)/g;
+  for (const match of manifest.replace(/^\s*\/\/.*$/gm, "").matchAll(dependency)) {
+    const root = import_node_path4.default.resolve(packagePath, match[1]);
+    if (import_node_fs3.default.existsSync(import_node_path4.default.join(root, "Package.swift"))) roots.add(root);
+  }
+  return [...roots].sort();
+}
 function sourceStamp(packagePath) {
   const hash = (0, import_node_crypto2.createHash)("sha256");
-  for (const file of sourceFiles(packagePath).sort()) {
-    hash.update(import_node_path4.default.relative(packagePath, file));
-    hash.update(String(import_node_fs3.default.statSync(file).mtimeMs));
+  for (const root of [packagePath, ...linkedModuleRoots(packagePath)]) {
+    hash.update(root);
+    for (const file of sourceFiles(root).sort()) {
+      hash.update(import_node_path4.default.relative(root, file));
+      hash.update(String(import_node_fs3.default.statSync(file).mtimeMs));
+    }
   }
   return hash.digest("hex").slice(0, 16);
 }
+function viewRootId(packagePath, file) {
+  return import_node_path4.default.join(packagePath, import_node_path4.default.relative(packagePath, file));
+}
 function artifactUrl(project, artifact) {
   const address = devServer?.httpServer?.address();
   const port = address && typeof address === "object" ? address.port : devServer?.config.server.port;
@@ -872,12 +900,36 @@ function artifactFor(project) {
   );
   return project.building;
 }
+function packageFor(file) {
+  let dir = import_node_path4.default.dirname(file);
+  const stop = devServer?.config.root;
+  for (; ; ) {
+    if (import_node_fs3.default.existsSync(import_node_path4.default.join(dir, "Package.swift"))) return dir;
+    if (stop !== void 0 && dir === stop || import_node_path4.default.dirname(dir) === dir) break;
+    dir = import_node_path4.default.dirname(dir);
+  }
+  throw new Error(
+    `no Package.swift above ${file}${stop === void 0 ? "" : ` (searched up to ${stop})`}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`
+  );
+}
+function isViewPackage(packagePath) {
+  const main = /@main\s+(?:\w+\s+)*(?:struct|class|enum|actor)\s+\w+[^{]*:\s*[^{]*\bRNXPackage\b/;
+  for (const file of sourceFiles(packagePath)) {
+    const text = import_node_fs3.default.readFileSync(file, "utf8").replace(/^\s*\/\/.*$/gm, "");
+    if (main.test(text)) return true;
+  }
+  return false;
+}
 function swiftPlugin(options = {}) {
-  const packagePathFor = (file) => options.packagePath ?? rootFor(file);
   return {
     name: "rnx-swift",
     enforce: "pre",
     async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX)) return source;
+      if (source.startsWith("/@id/")) {
+        const decoded = source.slice("/@id/".length).replace(/^__x00__/, "\0");
+        return decoded.startsWith(VIRTUAL_PREFIX) ? decoded : null;
+      }
       if (!source.endsWith(".swift")) return null;
       const resolved = await this.resolve(source, importer, { skipSelf: true });
       if (!resolved) throw new Error(`cannot resolve swift source ${source}`);
@@ -885,9 +937,13 @@ function swiftPlugin(options = {}) {
     },
     async load(id) {
       if (!id.startsWith(VIRTUAL_PREFIX)) return null;
-      const packagePath = packagePathFor(id.slice(VIRTUAL_PREFIX.length));
+      const file = id.slice(VIRTUAL_PREFIX.length);
+      const packagePath = options.packagePath ?? packageFor(file);
       const project = projectFor(packagePath);
       for (const source of sourceFiles(packagePath)) this.addWatchFile(source);
+      for (const root of linkedModuleRoots(packagePath)) {
+        for (const source of sourceFiles(root)) this.addWatchFile(source);
+      }
       let artifact;
       try {
         artifact = await artifactFor(project);
@@ -896,6 +952,14 @@ function swiftPlugin(options = {}) {
         this.warn(error instanceof Error ? error.message : String(error));
         artifact = project.artifact;
       }
+      if (isViewPackage(packagePath)) {
+        const rootId = viewRootId(packagePath, file);
+        return [
+          `import { createSwiftView } from 'rnxsim/swift'`,
+          `export default createSwiftView({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(rootId)} })`,
+          ""
+        ].join("\n");
+      }
       return [
         `import { createSwiftModule } from 'rnxsim/swift'`,
         `export default createSwiftModule({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)} })`,
@@ -904,30 +968,28 @@ function swiftPlugin(options = {}) {
     },
     configureServer(server) {
       devServer = server;
-      const packagePath = packagePathFor("");
       server.middlewares.use((req, res, next) => {
         const url = (req.url ?? "").split("?")[0];
         if (!url.startsWith(ARTIFACT_PATH)) {
           next();
           return;
         }
-        const project = projectFor(packagePath);
-        void artifactFor(project).then(
-          (artifact) => {
-            if (url !== `${ARTIFACT_PATH}${artifact.hash}.wasm`) {
-              res.statusCode = 404;
-              res.end("swift artifact is stale");
+        void (async () => {
+          for (const project of projects.values()) {
+            const artifact = await artifactFor(project);
+            if (url === `${ARTIFACT_PATH}${artifact.hash}.wasm`) {
+              res.setHeader("access-control-allow-origin", "*");
+              res.setHeader("content-type", "application/wasm");
+              res.end(artifact.bytes);
               return;
             }
-            res.setHeader("access-control-allow-origin", "*");
-            res.setHeader("content-type", "application/wasm");
-            res.end(artifact.bytes);
-          },
-          (error) => {
-            res.statusCode = 500;
-            res.end(error instanceof Error ? error.message : String(error));
           }
-        );
+          res.statusCode = 404;
+          res.end("swift artifact is stale");
+        })().catch((error) => {
+          res.statusCode = 500;
+          res.end(error instanceof Error ? error.message : String(error));
+        });
       });
     }
   };
@@ -938,6 +1000,17 @@ function rnxPlugin(options = {}) {
   const prefix = options.prefix || "/__soot";
   return {
     name: "sootsim-one",
+    // use-latest-callback ships a CJS main (module.exports, no default) with
+    // an esm.mjs shim that re-imports it. react-native-bottom-tabs
+    // default-imports it from source served live, so vite hands the browser
+    // the raw CJS file and the import fails with 'does not provide an export
+    // named default' before anything mounts. forcing it through dep
+    // optimization lets esbuild's CJS interop answer the default import, and
+    // every bare import of it (including the nested copy's) resolves to the
+    // one pre-bundled instance.
+    config() {
+      return { optimizeDeps: { include: ["use-latest-callback"] } };
+    },
     configureServer(server) {
       if (options.enabled === false) return;
       const bundleUrl = options.bundleUrl || "/node_modules/one/metro-entry.bundle?platform=ios&dev=true&minify=false";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rnxsim",
-  "version": "0.1.519",
+  "version": "0.1.521",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for rnx.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/scripts/dev-server-scanner.ts

@@ -94,6 +94,10 @@ export interface DiscoveredServer {
   lastSeen: number
   iconUrl?: string
   iconPath?: string
+  /** the app's own brand colour from its manifest, used as the home tile's
+   *  background so the tile reads as that app before its icon decodes and
+   *  when the icon is missing entirely. */
+  primaryColor?: string
   bundleId?: string
   settingsBundle?: readonly AppSettingsSpecifier[]
   settingsStorageScopeUrl?: string
@@ -594,6 +598,43 @@ function safeParseManifest(body: string): Record<string, unknown> | null {
   }
 }
 
+// a manifest icon path ("./assets/app-icons/x.png") is relative to the project
+// root. metro's asset route prefixes the whole relative path with /assets/; a
+// statically-served project answers at the literal path. the manifest says
+// nothing about which, so the two candidates are probed once per port and the
+// winner cached. keyed by port and cleared with the rest of that port's state
+// when the process disappears.
+const localIconPathCache = new Map<number, string>()
+const localIconProbeInFlight = new Set<number>()
+
+function metroAssetPath(rawIcon: string): string {
+  return `/assets/${rawIcon.replace(/^\.?\//, '')}`
+}
+
+function staticAssetPath(rawIcon: string): string {
+  return `/${rawIcon.replace(/^\.?\//, '')}`
+}
+
+// probe both shapes and cache whichever the server actually serves. resolves
+// nothing when neither answers — the tile falls back to the app's brand colour.
+async function resolveLocalIconPath(
+  hostname: string,
+  port: number,
+  rawIcon: string,
+): Promise<void> {
+  const candidates = [metroAssetPath(rawIcon), staticAssetPath(rawIcon)]
+  for (const candidate of candidates) {
+    const res = await httpGet(hostname, port, candidate, 'HEAD', ENRICH_TIMEOUT_MS)
+    if (res?.statusCode === 200) {
+      localIconPathCache.set(port, candidate)
+      // the identified result caches as a strong entry and won't re-probe on
+      // its own; drop it so the next scan republishes with the working url.
+      portCache.delete(port)
+      return
+    }
+  }
+}
+
 // fold expo manifest fields (name, icon, bundleId, launchAsset) into a result.
 // the manifest body is always the GET / response we already have from probePort,
 // so this never issues another http request.
@@ -607,6 +648,7 @@ function applyManifest(
     const manifest = JSON.parse(manifestRes.body)
     const client = manifest?.extra?.expoClient || manifest?.extra || {}
     if (client.name) result.projectName = client.name
+    if (typeof client.primaryColor === 'string') result.primaryColor = client.primaryColor
     if (client.ios?.bundleIdentifier) result.bundleId = client.ios.bundleIdentifier
     if (result.framework === 'metro' && client.sdkVersion) result.framework = 'expo'
     // preserve a confirmed direct one/vxrn metro-entry bundle. expo manifests
@@ -645,11 +687,16 @@ function applyManifest(
           resolvedIconUrl = rawIcon
         }
       } else {
-        const cleanPath = rawIcon.replace(/^\.?\//, '')
-        const assetPath = cleanPath.startsWith('assets/')
-          ? `/${cleanPath}`
-          : `/assets/${cleanPath}`
-        const localUrl = `${buildLoopbackProbeBaseUrl('http:', manifestRes.hostname, result.port)}${assetPath}`
+        // a manifest icon path is relative to the project root, and the two
+        // server shapes we meet serve it at different URLs: metro's asset route
+        // is `/assets/` + that whole relative path (so `assets/x.png` lands at
+        // `/assets/assets/x.png`), while a statically-served project answers at
+        // the literal path. neither shape can be derived from the manifest, so
+        // resolveLocalIconPath probes the server once and caches the answer;
+        // until it lands we publish the metro form, which is the common case.
+        const base = buildLoopbackProbeBaseUrl('http:', manifestRes.hostname, result.port)
+        const assetPath = localIconPathCache.get(result.port) ?? metroAssetPath(rawIcon)
+        const localUrl = `${base}${assetPath}`
         resolvedIconUrl = buildIconProxyUrl ? buildIconProxyUrl(localUrl) : localUrl
       }
       if (resolvedIconUrl) {
@@ -700,6 +747,21 @@ interface ManifestEnrichment {
 const enrichmentCache = new Map<number, ManifestEnrichment>()
 const enrichmentInFlight = new Set<number>()
 
+// a result that carries a relative icon path has not had its serving shape
+// confirmed yet. probe once per port; applyManifest reads the cached answer.
+function ensureLocalIconPathResolved(result: DiscoveredServer): void {
+  const rawIcon = result.iconPath
+  if (!rawIcon) return
+  if (rawIcon.startsWith('http://') || rawIcon.startsWith('https://')) return
+  if (localIconPathCache.has(result.port)) return
+  if (localIconProbeInFlight.has(result.port)) return
+  localIconProbeInFlight.add(result.port)
+  const hostname = normalizeHostname(new URL(result.bundleUrl).hostname)
+  void resolveLocalIconPath(hostname, result.port, rawIcon).finally(() =>
+    localIconProbeInFlight.delete(result.port),
+  )
+}
+
 // apply already-captured name/icon, or kick off a single background manifest
 // fetch to capture them. a no-op once the in-race manifest already named the
 // server, so it's safe to wrap every identified return.
@@ -707,6 +769,7 @@ function enrichWithManifest(
   result: DiscoveredServer,
   buildIconProxyUrl?: (externalUrl: string) => string,
 ): DiscoveredServer {
+  ensureLocalIconPathResolved(result)
   if (result.projectName) return result
 
   const cached = enrichmentCache.get(result.port)
@@ -1157,6 +1220,9 @@ export async function scanDevServers(
   for (const p of [...enrichmentCache.keys()]) {
     if (!currentPorts.has(p)) enrichmentCache.delete(p)
   }
+  for (const p of [...localIconPathCache.keys()]) {
+    if (!currentPorts.has(p)) localIconPathCache.delete(p)
+  }
 
   const results: DiscoveredServer[] = []
   const toProbe: ListeningProcess[] = []
@@ -1179,6 +1245,7 @@ export async function scanDevServers(
       knownOne.delete(port)
       // a restarted process may be a different app — drop its captured name/icon.
       enrichmentCache.delete(port)
+      localIconPathCache.delete(port)
     }
     toProbe.push({ port, pid })
   }

package/src/bridge-contract-input.ts

@@ -435,9 +435,19 @@ export function parseResetOptions(value: unknown): ResetOptions {
   if (strategy !== 'data' && strategy !== 'full') {
     return validationFailure('reset.strategy', 'must be data or full')
   }
+  // the shape check only; the simulator service re-validates the id against
+  // its own strict pattern and the caller's account before touching storage.
+  const from = input.from
+  if (
+    from !== undefined &&
+    (typeof from !== 'string' || from.length === 0 || from.length > 64)
+  ) {
+    return validationFailure('reset.from', 'must name a simulator')
+  }
   return {
     strategy,
     relaunch: optionalBoolean(input, 'relaunch', 'reset') ?? true,
+    ...(from === undefined ? {} : { from }),
   }
 }
 

package/src/bridge-contract.ts

@@ -502,6 +502,11 @@ export interface ResetOptions extends Pick<
   strategy?: ResetStrategy
   // relaunch the app after wiping. default true.
   relaunch?: boolean
+  // boot the wiped simulator on a live copy of another simulator's storage
+  // instead of empty stores: the cheap clean-but-not-cold seam. the id names
+  // a simulator on the same account; runtimes that cannot reach another
+  // simulator's storage refuse it by name rather than wiping without forking.
+  from?: string
 }
 
 export interface ResetResult {

package/src/cloud-contract.ts

@@ -6,7 +6,13 @@ export const RNX_CLOUD_DESIGN_MAX_STORAGE_BYTES = 1024 * 1024
 export const RNX_CLOUD_TEST_FILES_MAX_COUNT = 256
 export const RNX_CLOUD_TEST_FILES_MAX_BYTES = 500_000
 
-export type RnxCloudCommandScope = 'read' | 'drive' | 'reset' | 'media' | 'debug' | 'watch'
+export type RnxCloudCommandScope =
+  | 'read'
+  | 'drive'
+  | 'reset'
+  | 'media'
+  | 'debug'
+  | 'watch'
 
 const RNX_CLOUD_COMMAND_SCOPE_SET = new Set<string>([
   'read',

package/src/cloud.ts

@@ -9,7 +9,6 @@
 // public surface.
 
 import { isLoopbackHost } from './backend-origin'
-import type { SimStateOptions } from './bridge-contract'
 import { isRnxScreenCapture, type RnxScreenCapture } from './capture-contract'
 import {
   isRnxCloudCommandScope,
@@ -27,6 +26,7 @@ import {
   type RnxCloudScopedToken,
 } from './cloud-contract'
 import { rnxPublicBrand } from './public-brand'
+import type { SimStateOptions } from './bridge-contract'
 
 export {
   isRnxCloudCommandScope,
@@ -93,7 +93,12 @@ export interface RnxCommands {
   // a `data:image/png;base64,` url, assembled by the service from the frame
   screenshot(options?: { layers?: 'full' | 'tenant' | 'shell' }): Promise<string>
   capture(): Promise<RnxScreenCapture>
-  reset(): Promise<unknown>
+  // data wipes the app's stores and cold-remounts, keeping install-scoped
+  // credentials; full clears those too. from boots the wiped simulator on a
+  // wholesale live copy of another simulator's storage instead of empty
+  // stores. the bundle itself is never reinstalled: artifacts are immutable
+  // and sha-addressed, so there is no install to redo.
+  reset(options?: { strategy?: 'data' | 'full'; from?: string }): Promise<unknown>
   // the one-call read: screenshot, tree, route, and recent errors together.
   state(options?: SimStateOptions): Promise<unknown>
 }
@@ -433,10 +438,39 @@ export class RemoteSimulator {
         }
         return result
       },
-      reset: () => this.sendCommand({ type: 'reset' }),
+      reset: (options) => {
+        if (
+          options?.strategy !== undefined &&
+          options.strategy !== 'data' &&
+          options.strategy !== 'full'
+        ) {
+          throw new Error('RNX Cloud reset strategy must be data or full')
+        }
+        if (
+          options?.from !== undefined &&
+          (typeof options.from !== 'string' || options.from.length === 0)
+        ) {
+          throw new Error('RNX Cloud reset from must name a simulator')
+        }
+        return this.sendCommand(
+          options === undefined
+            ? { type: 'reset' }
+            : {
+                type: 'reset',
+                resetOptions: {
+                  ...(options.strategy === undefined
+                    ? {}
+                    : { strategy: options.strategy }),
+                  ...(options.from === undefined ? {} : { from: options.from }),
+                },
+              },
+        )
+      },
       state: (options) =>
         this.sendCommand(
-          options === undefined ? { type: 'state' } : { type: 'state', stateOptions: options },
+          options === undefined
+            ? { type: 'state' }
+            : { type: 'state', stateOptions: options },
         ),
     }
   }
@@ -653,7 +687,10 @@ function readConnectClaim(value: unknown): RnxCloudClaim | null {
   return readClaim(value)
 }
 
-function readConnectScopes(value: unknown, token: string): readonly RnxCloudCommandScope[] {
+function readConnectScopes(
+  value: unknown,
+  token: string,
+): readonly RnxCloudCommandScope[] {
   // the full per-simulator token carries every scope except debug, which the
   // service already guarantees. a scoped token learns its verbs from the get
   // it just made, so a verb outside them is refused before any request.
@@ -678,7 +715,9 @@ function readConnectScopes(value: unknown, token: string): readonly RnxCloudComm
 // attach to a simulator another process created. one get proves the token,
 // and the simulator it returns drives with that token's scopes, takes no
 // claim, and never steals one.
-export async function connect(input: ConnectRemoteSimulatorInput): Promise<RemoteSimulator> {
+export async function connect(
+  input: ConnectRemoteSimulatorInput,
+): Promise<RemoteSimulator> {
   if (!input.id) throw new Error('RNX Cloud connect needs a simulator id')
   if (!input.token) throw new Error('RNX Cloud connect needs a token')
   const origin = resolveOrigin(input.origin)

package/src/connect.ts

@@ -67,7 +67,7 @@ export async function connect(options: ConnectOptions = {}): Promise<SimClient>
     const bridge = createCloudBridgeForParsed(target)
     if (!bridge)
       throw new SimConnectError('remote simulator session disappeared while connecting')
-    return new SimClient(bridge, cloud.service === 'box' ? cloud.boxId : cloud.simId, {
+    return new SimClient(bridge, cloud.simId, {
       commandTimeoutMs: options.timeoutMs ?? 15_000,
     })
   }

package/src/menu.ts

@@ -29,6 +29,28 @@ export const SOOTSIM_AMBIENT_GLOW_LABELS: Record<SootSimAmbientGlowLevel, string
   full: 'Full',
 }
 
+// which ios home screen the simulator portrays. the home screen is authored
+// twice (the flat ios 26 home and the ios 27 home measured off apple's art),
+// so the era is one value every host carries: the menus, the persisted
+// setting, the ?homeScreen= boot seed, the live set-home-screen push and
+// electron's shared config.
+export type SootSimHomeScreenVersion = 'ios26' | 'ios27'
+export const SOOTSIM_HOME_SCREEN_VERSIONS = ['ios26', 'ios27'] as const
+
+export function isSootSimHomeScreenVersion(
+  value: unknown,
+): value is SootSimHomeScreenVersion {
+  return value === 'ios26' || value === 'ios27'
+}
+
+export const SOOTSIM_HOME_SCREEN_VERSION_LABELS: Record<
+  SootSimHomeScreenVersion,
+  string
+> = {
+  ios26: 'iOS 26',
+  ios27: 'iOS 27',
+}
+
 export type SootSimMenuItemDef =
   | { type: 'separator' }
   | {
@@ -56,6 +78,11 @@ export type SootSimMenuDef = {
 
 export interface SootSimMenuState {
   currentDevice: string
+  homeScreenVersion: SootSimHomeScreenVersion
+  // whether this surface is a contributor development surface. unreleased
+  // simulator surfaces (the iPhone Duo and its home-screen era switch) are
+  // offered here and nowhere a user can reach.
+  developmentMode: boolean
   showBezels: boolean
   showMenuBar: boolean
   showRail: boolean
@@ -455,6 +482,23 @@ function windowMenu(state: SootSimMenuState): SootSimMenuDef {
           actionPayload: level,
         })),
       },
+      // both eras stay selectable while the ios 27 home surfaces land one at a
+      // time, and the device's own os picks the starting value. the switch is
+      // the iPhone Duo's, so it is offered exactly where the Duo is.
+      ...(state.developmentMode
+        ? [
+            {
+              label: 'Home Screen',
+              items: SOOTSIM_HOME_SCREEN_VERSIONS.map((version) => ({
+                label: SOOTSIM_HOME_SCREEN_VERSION_LABELS[version],
+                type: 'radio' as const,
+                checked: state.homeScreenVersion === version,
+                action: 'set-home-screen',
+                actionPayload: version,
+              })),
+            },
+          ]
+        : []),
       {
         label: 'Wireframe',
         type: 'checkbox',

package/src/swift.ts

@@ -2,5 +2,7 @@
 // implementation lives beside the toolchain it drives, in sootsim-swift.
 export {
   createSwiftModule,
+  createSwiftView,
   type SwiftModuleOptions,
+  type SwiftViewOptions,
 } from '../../sootsim-swift/src/mount.tsx'

package/src/vite-plugin-one.ts

@@ -46,6 +46,18 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
   return {
     name: 'sootsim-one',
 
+    // use-latest-callback ships a CJS main (module.exports, no default) with
+    // an esm.mjs shim that re-imports it. react-native-bottom-tabs
+    // default-imports it from source served live, so vite hands the browser
+    // the raw CJS file and the import fails with 'does not provide an export
+    // named default' before anything mounts. forcing it through dep
+    // optimization lets esbuild's CJS interop answer the default import, and
+    // every bare import of it (including the nested copy's) resolves to the
+    // one pre-bundled instance.
+    config() {
+      return { optimizeDeps: { include: ['use-latest-callback'] } }
+    },
+
     configureServer(server) {
       if (options.enabled === false) return
       const bundleUrl =