sootsim 0.1.304 → 0.1.306

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.304 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.306 | (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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sootsim",
-  "version": "0.1.304",
+  "version": "0.1.306",
   "description": "sootsim CLI + vite/metro plugins + skills registry. bridge client for driving the proprietary sootsim-engine over WebSocket.",
   "author": "Tamagui LLC",
   "license": "MIT",

package/scripts/dev-server-scanner.ts

@@ -29,14 +29,6 @@ import {
 } from '../src/settings-bundle.ts'
 import { loadOptionalDemoApps, optionalDemoAppsSync } from './optional-demo-registry.ts'
 
-// pre-warm the optional internal demo registry once at module load. in-repo
-// (electron tray / `bun run demo` discovery) this resolves the source registry
-// so a launched demo's runtimeConfig is folded into its bundle URL; on a
-// published install the registry was never shipped, so this resolves to [] and
-// every dev server is treated generically. either way `withRuntimeConfig` below
-// reads the synchronous cached view.
-void loadOptionalDemoApps()
-
 export interface DiscoveredServer {
   port: number
   framework: 'metro' | 'expo' | 'vxrn' | 'one' | 'unknown'
@@ -556,6 +548,11 @@ export async function probePort(
   port: number,
   buildIconProxyUrl?: (externalUrl: string) => string,
 ): Promise<DiscoveredServer | null> {
+  // callers such as `sootsim open <port>` probe one port directly instead of
+  // going through scanDevServers. wait for the optional in-repo registry here
+  // too, or a cold CLI process can build the known app's bundle url before its
+  // runtime config is available.
+  await loadOptionalDemoApps()
   if (!(await tcpPing(port))) return null
 
   const onePath = `/node_modules/one/metro-entry.bundle?platform=ios&dev=true`
@@ -824,13 +821,10 @@ export const __attachAppSettingsBundleForTests = attachAppSettingsBundle
 export async function scanDevServers(
   opts: ScanOptions = {},
 ): Promise<DiscoveredServer[]> {
-  // await the registry rather than trusting the module-init prewarm to have
-  // won. optionalDemoAppsSync() returns [] until that dynamic import resolves,
-  // and an empty registry is indistinguishable from a published install, so a
-  // scan in that window silently drops a known app's runtimeConfig and hands
-  // back a bundle URL with no sootsimConfig at all. it is already resolved by
-  // the time any real scan runs, which is exactly why the window is easy to
-  // miss; it opens when disk is contended. memoized, so this is free after the
+  // optionalDemoAppsSync() returns [] until the dynamic import resolves, and
+  // an empty registry is indistinguishable from a published install. await it
+  // before cache validation so a known app cannot lose its runtimeConfig when
+  // disk contention delays the import. memoized, so this is free after the
   // first call.
   await loadOptionalDemoApps()
   const processes = await discoverListeningProcesses(opts.excludePorts)

package/scripts/optional-demo-registry.ts

@@ -8,17 +8,54 @@
 // apps — shipping the registry once matched a brand-new user's `expo start` on
 // the default port 8081 against the 3pc `one` entry and crashed their metro
 // (repo-agnostic-pipeline violation). so the registry is NOT in the package
-// `files` list and is marked external in `scripts/build-cli.ts`, which leaves
-// this `import()` as a runtime dynamic import: it resolves the source registry
-// in-repo and resolves to nothing (empty list) on a published install.
+// `files` list, and the `import()` below is resolved to an absolute path at
+// runtime: it finds the source registry in-repo and nothing (empty list) on a
+// published install. no bundler can see through that, so it never inlines.
 //
 // one path, no env toggle: every consumer goes through this loader; whether the
 // registry resolves is purely a function of whether the file exists on disk.
 
-// the path is assembled at runtime so neither esbuild nor a bundler treats it
-// as a static dependency to inline — it stays a true dynamic import resolved
-// against the package's own scripts dir at runtime.
-const REGISTRY_SPECIFIER = './demo-app-registry.ts'
+import { existsSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+// this module is emitted at three different depths — the source at
+// packages/sootsim/scripts/, the built CLI at packages/sootsim/dist-cli/chunks/,
+// and the electron main bundle at packages/sootsim-engine/dist-electron/ — so a
+// relative './demo-app-registry.ts' is only correct from the source copy. from
+// the other two it points at a file that does not exist, the catch below
+// swallows that, and every demo app then boots with no runtimeConfig at all
+// (mattermost stops on the server-select screen because AutoSelectServerUrl
+// never reaches it). the one description that holds from every emit site is the
+// ancestor that holds the registry at its repo path, which in-repo is the
+// monorepo root.
+const REGISTRY_REPO_PATH = 'packages/sootsim/scripts/demo-app-registry.ts'
+
+// the walk must never leave the installed package. `sootsim` publishes this
+// loader's source, so on a published install it runs from
+// node_modules/sootsim/scripts/ (or dist-cli/chunks/) with the consumer's whole
+// filesystem above it — and consumers include this repo's own templates and
+// examples, which install sootsim while sitting inside the monorepo. an
+// unbounded walk from there reaches the real registry and hands a user's
+// `expo start` on port 8081 the internal 3pc entry, which is the exact incident
+// the header describes. a node_modules ancestor means "installed as a
+// dependency", so the search stops there and the registry stays absent.
+const MAX_ANCESTOR_STEPS = 8
+
+/** absolute path to the internal registry, or null when this copy is running
+ *  outside the monorepo (a published install) and must not have one. */
+export function findInternalDemoRegistry(startDir: string): string | null {
+  let dir = startDir
+  for (let step = 0; step < MAX_ANCESTOR_STEPS; step++) {
+    if (basename(dir) === 'node_modules') return null
+    const candidate = join(dir, REGISTRY_REPO_PATH)
+    if (existsSync(candidate)) return candidate
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+  return null
+}
 
 export interface OptionalDemoApp {
   name: string
@@ -35,8 +72,13 @@ let cached: OptionalDemoApp[] | null = null
  *  returns [] on a published install where the registry was not shipped. */
 export async function loadOptionalDemoApps(): Promise<OptionalDemoApp[]> {
   if (cached) return cached
+  const registryPath = findInternalDemoRegistry(dirname(fileURLToPath(import.meta.url)))
+  if (!registryPath) {
+    cached = []
+    return cached
+  }
   try {
-    const mod = (await import(/* @vite-ignore */ REGISTRY_SPECIFIER)) as {
+    const mod = (await import(/* @vite-ignore */ pathToFileURL(registryPath).href)) as {
       APPS?: OptionalDemoApp[]
     }
     cached = Array.isArray(mod.APPS) ? mod.APPS : []
@@ -47,8 +89,8 @@ export async function loadOptionalDemoApps(): Promise<OptionalDemoApp[]> {
 }
 
 /** synchronous view of the registry — empty until `loadOptionalDemoApps()` has
- *  resolved at least once. the scanner pre-warms this at module init so its
- *  synchronous per-port lookup can stay synchronous. */
+ *  resolved at least once. every caller that builds a result from the registry
+ *  awaits the load first. */
 export function optionalDemoAppsSync(): OptionalDemoApp[] {
   return cached ?? []
 }

package/skills/sootsim-debug/SKILL.md

@@ -64,11 +64,10 @@ regression test. a pile of ad-hoc logs helps no one and gets deleted.
 - **pin a sim once.** if more than one is live, an unpinned command
   refuses to choose. run `sootsim use <id>` at the start of the workflow.
 - **keep one sim and reuse its browser tab.** before `sootsim open`, run
-  `sootsim list --all`. if the target is already connected, pin it and use
-  `sootsim do reload`; do not open another tab to reload or retry a capture.
-  re-run `list --all` after each reload or reconnect; when another entry appears,
-  run `sootsim close --others` against the pinned sim immediately.
-  if the current sim must be replaced, close it before opening the replacement.
+  `sootsim list --all`. pin the target and use `sootsim do reload`; a plain
+  `sootsim open <target>` also navigates the saved sim. reserve `--new` for a
+  genuinely concurrent sim. repeated browser trees consume memory and CPU on a
+  shared machine.
 - **`debug eval` is an escape hatch.** if a top-level command feels
   broken or missing, file an issue — every agent after you benefits from
   a better CLI, not a pile of ad-hoc scripts.

package/skills/sootsim-setup/SKILL.md

@@ -15,60 +15,45 @@ debugging or `/sootsim-test` for writing tests.
 ## anti-patterns (read first)
 
 - **never `sootsim claim --force` a sim held by another CLI.** the lease
-  exists for a reason — forcing strands the other agent and corrupts the
+  exists for a reason. forcing strands the other agent and corrupts the
   bridge state. use `sootsim open --new` to start a fresh sim instead.
 - **don't switch sims mid-investigation.** pin once with `sootsim use
   <id>` and keep it pinned. an unpinned command refuses to choose when more
   than one driveable sim is live.
-- **an empty `sootsim list` is not "broken sootsim"** — it usually means the
+- **an empty `sootsim list` is not "broken sootsim".** it usually means the
   daemon is down, the dev server port is wrong, or the runtime is missing.
   walk the recovery checklist before reinstalling.
-- **one sim for your whole session. switch APPS by navigating that sim, never by
-  opening another.** `sootsim open <port> --sim <id>` resolves that exact sim and
-  navigates it in place — no new tab, no new browser tree. that is the supported
-  way to move between apps and ports:
+- **keep one sim for your whole session.** the first `sootsim open <port>`
+  launches Chrome for Testing with an isolated profile. later opens reuse the
+  saved sim and navigate it in place. use `sootsim do reload` when the target
+  has not changed:
 
   ```sh
-  sootsim open 8086 --sim <id>     # one app, in your sim
-  sootsim open 8090 --sim <id>     # a different app, same tab
-  sootsim reload --sim <id>        # reload whatever it is showing
-  sootsim close <id>               # dispose it when you are done
+  sootsim open 8086                 # first call creates your isolated sim
+  sootsim open 8090                 # same sim, different app
+  sootsim do reload                 # same sim, same app
+  sootsim close <id>                # dispose it when you are done
   ```
 
-  every `--new` spawns another browser tree, and each abandoned tab holds a
-  renderer process for the life of the browser. these land in somebody's actual
-  desktop Chrome. a run that opened one per app left 14 renderers against 2 live
-  sims on a shared machine and the owner noticed before we did.
-- **sharing a machine with other agents? open ONE sim with `--new`, pin it, and
-  pass `--sim <id>` from then on.** that single `--new` is the only one you get.
-  an unpinned command has no sim of its own, so it falls back to whatever sim is
-  currently PRIMARY — and that can be another agent's live sim, mid-run. a plain
-  `sootsim open <port>` from an unpinned CLI will happily retarget somebody
-  else's sim to your port and take over their session; the warning it prints is
-  easy to miss in a transcript. the current-sim pin is stored per CLI identity
-  (`sootsim-current-sim-<identity>.json`, keyed by your process-tree root), so
-  pinning is genuinely per-agent and does not fight anyone else:
+  `--new`, `--profile`, and `--ephemeral` create another isolated browser
+  tree. use them only when separate storage or a genuinely concurrent sim is
+  required. repeated new trees consume enough memory and CPU to starve other
+  work on a shared machine.
+- **pin the sim before driving it.** `sootsim open` records the new sim for the
+  current CLI identity. read its id and pin it explicitly before a longer flow:
 
   ```sh
-  sootsim open --new 8086          # your own sim; also records it as yours
-  sootsim list                     # read back its id
-  sootsim use <id>                 # pin it explicitly
-  sootsim describe --sim <id>      # name it on every command after that
+  sootsim open 8086
+  sootsim list
+  sootsim use <id>
+  sootsim describe --sim <id>
   ```
 
-  `--new`, `--profile`, and `--ephemeral` are rejected outright when combined
-  with `--sim`, so if a command needs one of them you are starting a second sim
-  whether you meant to or not. if yours died, run `sootsim list --all` and adopt
-  an open unlocked sim with `sootsim use <id>` before you consider opening one.
-  always close yours when you finish.
 - **never retry-loop `sootsim open` against a wedged or slow stack.** a
-  connect-timeout ("timed out waiting for opened sim to connect") means STOP and
-  diagnose — not retry. each retried open spawns a new browser tree (a
-  software-render `headless_shell` under the bundled chromium), and a pile of
-  them is a machine-meltdown vector (incident 2026-07-08: a retry-loop of opens
-  against a wedged mobile stack drove a load emergency). reuse ONE persistent
-  sim tab and reload — never new-tab-per-attempt — and launch GPU chrome
-  (`channel:'chrome'`), not the bundled `headless_shell`.
+  connect timeout means diagnose the stack. do not retry. if the first launch
+  never connects, each retry can create another browser tree before there is a
+  saved sim to reuse. verify the development server and SootSim runtime, then
+  retry once after fixing the cause.
 
 ## first move
 
@@ -151,16 +136,11 @@ sootsim close <id>               # release it cleanly
 Run `sootsim runtime install`, then retry `sootsim open <port>`.
 
 **`sootsim open` times out ("timed out waiting for opened sim to connect").**
-do NOT retry the open in a loop — each attempt spawns a browser tree, and
-reopening a wedged/slow stack repeatedly is a machine-meltdown pattern. diagnose
-instead: check machine load (`sysctl -n vm.loadavg` — a starved box boots the
-engine too slowly to register) and the dev stack's health (`/__soot/` should
-200; a partial `dev:*` stack with no engine watchers can serve a stale engine
-dist that never connects, and a wedged one-dev logging unhandled rejections
-won't boot a fresh sim). if load is high, let it settle before ONE more try. if
-the stack is wedged, restart it cleanly rather than reopening. always launch GPU
-chrome (`channel:'chrome'`), never the bundled `headless_shell` — software
-rendering pegs every core for the canvas's whole lifetime.
+do not retry in a loop. verify the development server first: `__soot/` must
+respond and the engine watchers must be running. inspect the driver diagnostic
+path printed by the failed command. restart the broken development stack at its
+supervisor, then retry once. SootSim owns the isolated browser profile and its
+process tree; do not open the shell URL through an operating-system browser.
 
 **bridge disconnects mid-sim.** the WebSocket dropped (laptop slept,
 network blip). re-pin: `sootsim use <id>`. the daemon retries reconnection

package/src/bridge-constants.ts

@@ -71,6 +71,21 @@ function closestLocalDevBaseHttpPort(httpPort: number): number | null {
   return closest?.basePort ?? null
 }
 
+/** the vite dev shell that shares a world with a bridge port. the two are one
+ *  offset apart by construction (bridge 7668 + N, shell 5173 + N), so a caller
+ *  that pinned an explicit bridge port can name its own shell directly. that
+ *  matters because the dev-bridge lockfile records only the stack that
+ *  heartbeated last: on a machine running several worktree stacks it routinely
+ *  names someone else's shell, and a page opened there while we poll our own
+ *  bridge never connects. null when the port is not a local dev bridge port. */
+export function resolveSootsimShellBaseUrlForBridgePort(
+  bridgePort: number,
+): string | null {
+  const offset = bridgePort - DEFAULT_SOOTSIM_BRIDGE_PORT
+  if (offset < 0 || offset > MAX_LOCAL_DEV_PORT_OFFSET) return null
+  return `http://localhost:${SOOTSIM_SHELL_DEV_HTTP_BASE_PORT + offset}/`
+}
+
 export function resolveSootsimBridgePortForRuntimeLocation(
   input: {
     explicitPort?: unknown

package/src/host/bridge-host.ts

@@ -939,22 +939,6 @@ export class SootSimBridgeHost {
               return
             }
 
-            if (msg.type === 'bridge:open') {
-              if (typeof msg.url !== 'string' || !msg.url) {
-                throw new Error('bridge:open requires a url')
-              }
-              await this.openUrl(msg.url, { newWindow: msg.newWindow === true })
-              if (ws.readyState === WebSocket.OPEN) {
-                ws.send(
-                  JSON.stringify({
-                    id: msg.id,
-                    result: { ok: true, url: msg.url },
-                  }),
-                )
-              }
-              return
-            }
-
             if (msg.type === 'bridge:claim') {
               const targetSim = await this.waitForSim(msg.simId)
               const outcome = this.tryAcquireLease(ws, targetSim, {

package/src/host/open-url.ts

@@ -1,19 +1,14 @@
-import { execFileSync, spawn } from 'child_process'
-import { existsSync } from 'fs'
-import { homedir } from 'os'
-import { join } from 'path'
+import { spawn } from 'child_process'
 
-export type OpenUrlLaunchVia = 'chromium' | 'system'
+export type OpenUrlLaunchVia = 'system'
 
 export interface OpenUrlOptions {
-  newWindow?: boolean
   detached?: boolean
   background?: boolean
 }
 
 export interface OpenUrlCommandOptions extends OpenUrlOptions {
   platform?: NodeJS.Platform
-  chromiumBinary?: string | null
 }
 
 export interface OpenUrlCommand {
@@ -28,97 +23,6 @@ export interface OpenUrlLaunchResult extends OpenUrlCommand {
   attachUrl: string
 }
 
-const MAC_CHROMIUM_CANDIDATES = [
-  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-  '~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-  '/Applications/Chromium.app/Contents/MacOS/Chromium',
-  '~/Applications/Chromium.app/Contents/MacOS/Chromium',
-  '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
-  '~/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
-  '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
-  '~/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
-  '/Applications/Arc.app/Contents/MacOS/Arc',
-  '~/Applications/Arc.app/Contents/MacOS/Arc',
-]
-
-const LINUX_CHROMIUM_CANDIDATES = [
-  '/usr/bin/google-chrome',
-  '/usr/bin/chromium',
-  '/usr/bin/chromium-browser',
-  '/usr/bin/microsoft-edge',
-  '/usr/bin/brave-browser',
-  '/snap/bin/chromium',
-]
-
-const WINDOWS_CHROMIUM_CANDIDATES = [
-  'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
-  'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
-  'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
-  'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
-  'C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
-  'C:\\Program Files (x86)\\BraveSoftware\\Brave-Browser\\Application\\brave.exe',
-]
-
-const UNIX_CHROMIUM_COMMANDS = [
-  'google-chrome',
-  'chromium',
-  'chromium-browser',
-  'microsoft-edge',
-  'brave-browser',
-]
-
-const WINDOWS_CHROMIUM_COMMANDS = ['chrome', 'msedge', 'brave']
-
-function expandHome(candidate: string): string {
-  return candidate.startsWith('~/') ? join(homedir(), candidate.slice(2)) : candidate
-}
-
-function firstExisting(candidates: string[]): string | null {
-  for (const candidate of candidates) {
-    const expanded = expandHome(candidate)
-    if (existsSync(expanded)) return expanded
-  }
-  return null
-}
-
-function lookupExecutable(command: string, platform: NodeJS.Platform): string | null {
-  try {
-    const tool = platform === 'win32' ? 'where' : 'which'
-    const out = execFileSync(tool, [command], {
-      encoding: 'utf8',
-      timeout: 1500,
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim()
-    return out ? out.split(/\r?\n/)[0] : null
-  } catch {
-    return null
-  }
-}
-
-export function resolveChromiumBinary(
-  platform: NodeJS.Platform = process.platform,
-): string | null {
-  const envCandidate = process.env.CHROME_PATH || process.env.CHROMIUM_PATH
-  if (envCandidate && existsSync(envCandidate)) return envCandidate
-
-  const direct =
-    platform === 'darwin'
-      ? firstExisting(MAC_CHROMIUM_CANDIDATES)
-      : platform === 'win32'
-        ? firstExisting(WINDOWS_CHROMIUM_CANDIDATES)
-        : firstExisting(LINUX_CHROMIUM_CANDIDATES)
-  if (direct) return direct
-
-  const commands =
-    platform === 'win32' ? WINDOWS_CHROMIUM_COMMANDS : UNIX_CHROMIUM_COMMANDS
-  for (const command of commands) {
-    const found = lookupExecutable(command, platform)
-    if (found) return found
-  }
-
-  return null
-}
-
 export function buildOpenUrlCommand(
   url: string,
   options: OpenUrlCommandOptions = {},
@@ -126,10 +30,6 @@ export function buildOpenUrlCommand(
   if (!url) throw new Error('openUrl requires a url')
 
   const platform = options.platform ?? process.platform
-  if (options.newWindow) {
-    return buildChromiumUrlCommand(url, { ...options, platform, newWindow: true })
-  }
-
   if (platform === 'darwin') {
     return {
       command: 'open',
@@ -153,38 +53,6 @@ export function buildOpenUrlCommand(
   }
 }
 
-export function buildChromiumUrlCommand(
-  url: string,
-  options: OpenUrlCommandOptions = {},
-): OpenUrlCommand {
-  if (!url) throw new Error('openUrl requires a url')
-
-  const platform = options.platform ?? process.platform
-  const chromiumBinary =
-    'chromiumBinary' in options ? options.chromiumBinary : resolveChromiumBinary(platform)
-  if (!chromiumBinary) {
-    throw new Error('browser launch requires Chrome, Chromium, Edge, Brave, or Arc')
-  }
-
-  // the chromium driver always launches a visible system browser window.
-  // headless is intentionally NOT supported here: bare `chrome --headless=new
-  // <url>` renders the page once and exits — nothing keeps the process (and
-  // therefore the sim) alive without an attached CDP client. headless
-  // automation is the playwright driver's job. see chromium.ts `launch`.
-  const args: string[] = []
-  if (options.newWindow !== false) {
-    args.push('--new-window')
-  }
-  args.push(url)
-
-  return {
-    command: chromiumBinary,
-    args,
-    via: 'chromium',
-    target: chromiumBinary,
-  }
-}
-
 async function spawnLaunch(
   command: string,
   args: string[],
@@ -216,19 +84,6 @@ export async function launchUrl(
   }
 }
 
-export async function launchChromiumUrl(
-  url: string,
-  options: OpenUrlCommandOptions = {},
-): Promise<OpenUrlLaunchResult> {
-  const command = buildChromiumUrlCommand(url, options)
-  const pid = await spawnLaunch(command.command, command.args, options.detached ?? true)
-  return {
-    ...command,
-    pid,
-    attachUrl: url,
-  }
-}
-
 export async function openUrl(url: string, options: OpenUrlOptions = {}): Promise<void> {
   await launchUrl(url, options)
 }

package/src/plist.ts

@@ -0,0 +1,27 @@
+import plistModule from '@expo/plist'
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function resolvePlistParser(value: unknown): ((source: string) => unknown) | null {
+  if (!isRecord(value)) return null
+  const direct = value.parse
+  if (typeof direct === 'function') {
+    return (source) => Reflect.apply(direct, value, [source])
+  }
+  const nested = value.default
+  if (!isRecord(nested)) return null
+  const nestedParse = nested.parse
+  return typeof nestedParse === 'function'
+    ? (source) => Reflect.apply(nestedParse, nested, [source])
+    : null
+}
+
+// bun consumes @expo/plist's default export directly, while the compiled commonjs
+// scanner receives the package namespace with that export nested under default.
+const parsePlist = resolvePlistParser(plistModule)
+
+export function parsePlistSource(source: string): unknown {
+  return parsePlist?.(source) ?? null
+}

package/src/settings-bundle.ts

@@ -1,6 +1,6 @@
 import { readFile, readdir, stat } from 'node:fs/promises'
 import { join } from 'node:path'
-import plistModule from '@expo/plist'
+import { parsePlistSource } from './plist.ts'
 import type { AppPreferenceValue, AppSettingsSpecifier } from '@sootsim/globals'
 
 const MAX_PLIST_BYTES = 1_048_576
@@ -26,26 +26,6 @@ function isRecord(value: unknown): value is PlistRecord {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
-function resolvePlistParser(value: unknown): ((source: string) => unknown) | null {
-  if (!isRecord(value)) return null
-  const direct = value.parse
-  if (typeof direct === 'function') {
-    return (source) => Reflect.apply(direct, value, [source])
-  }
-  const nested = value.default
-  if (!isRecord(nested)) return null
-  const nestedParse = nested.parse
-  return typeof nestedParse === 'function'
-    ? (source) => Reflect.apply(nestedParse, nested, [source])
-    : null
-}
-
-// bun consumes @expo/plist's default export directly, while the compiled commonjs
-// scanner receives the package namespace with that export nested under
-// `default`. resolve the parser once at this package boundary so source and
-// published scanners execute the same implementation.
-const parsePlist = resolvePlistParser(plistModule)
-
 function optionalString(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined
 }
@@ -196,11 +176,10 @@ async function settingsBundleFingerprint(bundlePath: string): Promise<string | n
 
 async function parsePlistRecord(path: string): Promise<PlistRecord | null> {
   try {
-    if (!parsePlist) return null
     const metadata = await stat(path)
     if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null
     const source = await readFile(path, 'utf8')
-    const parsed = parsePlist(source)
+    const parsed = parsePlistSource(source)
     return isRecord(parsed) ? parsed : null
   } catch {
     return null

package/src/skills/builtin/maestro-test.ts

@@ -31,6 +31,7 @@ export const skill: SootSimSkill = {
         const { DEFAULT_SOOTSIM_BRIDGE_PORT } = await import('../../bridge-constants')
         const { SootSimBridgeHost } = await import('../../host/bridge-host')
         const { createBridge } = await import('../../../cli/ws-bridge')
+        const { runOpenCommand } = await import('../../../cli/commands/control')
         const { SootSimBridgeFlowRunner } =
           await import('../../../cli/bridge-flow-runner')
 
@@ -44,7 +45,9 @@ export const skill: SootSimSkill = {
           const steps = yaml.parse(stepsBody)
           const beforeIds = new Set(host.listSims().map((sim) => sim.id))
 
-          await host.openUrl(context.url)
+          await runOpenCommand([context.url, '--new', '--headless', '--no-describe'], {
+            port: DEFAULT_SOOTSIM_BRIDGE_PORT,
+          })
 
           let simId: string | null = null
           for (let i = 0; i < 60; i++) {

package/src/vite-plugin.ts

@@ -54,6 +54,7 @@ const compatRoot = path.resolve(sootsimRoot, '..', 'compat')
 // renames of either package don't break things.
 const engineRoot = path.resolve(workspaceRoot, 'packages/sootsim-engine')
 const rnShimPath = path.resolve(engineRoot, 'src/react-native/index.ts')
+const rnWebShimPath = path.resolve(engineRoot, 'src/react-native-web.ts')
 const reactBridgePath = path.resolve(compatRoot, 'src/react-bridge.ts')
 const sootsimBrowserSourceAliases = [
   {
@@ -1007,7 +1008,7 @@ function sootsimConfigPlugin(
             })),
             { find: /^react-native\/Libraries\/.*/, replacement: rnDeepStubDefault },
             { find: 'react-native', replacement: rnShimPath },
-            { find: 'react-native-web', replacement: rnShimPath },
+            { find: 'react-native-web', replacement: rnWebShimPath },
             // resolved-path alias for the synthetic specifier the
             // @react-navigation/native compat wrapper imports from. terminates
             // the wrapper's own real-package import without re-entering the