rnxsim 0.1.519 → 0.1.520

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.519 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.520 | (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,19 @@ 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"
+};
+
+// 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:";
@@ -878,6 +885,11 @@ function swiftPlugin(options = {}) {
     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}`);
@@ -938,6 +950,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.520",
   "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/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,
@@ -436,7 +436,9 @@ export class RemoteSimulator {
       reset: () => this.sendCommand({ type: 'reset' }),
       state: (options) =>
         this.sendCommand(
-          options === undefined ? { type: 'state' } : { type: 'state', stateOptions: options },
+          options === undefined
+            ? { type: 'state' }
+            : { type: 'state', stateOptions: options },
         ),
     }
   }
@@ -653,7 +655,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 +683,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/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 =

package/src/vite-plugin-swift.ts

@@ -16,18 +16,20 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
+import toolchain from '../../sootsim-swift/toolchain.json'
 import type { Plugin, ViteDevServer } from 'vite'
 
 const run = promisify(execFile)
 
-// the toolchain layout scripts/build.sh pins. xcode's swift has no wasm
-// backend, so the swift.org toolchain and its matching wasm sdk are the only
-// ones that can build this target.
+// the swift.org release scripts/build.sh builds with, from the one place it is
+// named: the toolchain is <release>.xctoolchain and its matching wasm sdk is
+// <release>_wasm. xcode's swift has no wasm backend, so this toolchain is the
+// only one that can build the target.
 const TOOLCHAIN_BIN = path.join(
   os.homedir(),
-  'Library/Developer/Toolchains/swift-6.2-RELEASE.xctoolchain/usr/bin',
+  `Library/Developer/Toolchains/${toolchain.release}.xctoolchain/usr/bin`,
 )
-const WASM_SDK = 'swift-6.2-RELEASE_wasm'
+const WASM_SDK = `${toolchain.release}_wasm`
 const WASM_TRIPLE = 'wasm32-unknown-wasip1'
 
 const ARTIFACT_PATH = '/__rnx/swift/'
@@ -185,6 +187,16 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
     enforce: 'pre',
 
     async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX)) return source
+      // import-analysis re-resolves the served URL form of the id
+      // (/@id/__x00__..., with the null byte encoded) while transforming the
+      // importer. it still names this module, so answer the decoded id; any
+      // other /@id/ url is already resolved and must not fall through to the
+      // filesystem resolve below, which would throw for it.
+      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}`)