peachsim 0.1.626 → 0.1.628

package/dist-lib/vite-kotlin.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.626 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.628 | (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/dist-lib/vite-swift.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.626 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.628 | (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/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.626 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.628 | (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;
@@ -47,6 +47,7 @@ var import_ws = require("ws");
 // src/bridge-constants.ts
 var DEFAULT_SOOTSIM_BRIDGE_PORT = 7668;
 var DEFAULT_SOOTSIM_BRIDGE_URL = `http://localhost:${DEFAULT_SOOTSIM_BRIDGE_PORT}/`;
+var AUTOMATION_SIM_IDLE_REAP_TTL_MS = 5 * 6e4;
 
 // src/dev-server-open.ts
 var import_node_child_process = require("node:child_process");
@@ -660,7 +661,11 @@ var MIME_TYPES = {
   ".woff": "font/woff",
   ".woff2": "font/woff2",
   ".mp3": "audio/mpeg",
-  ".wav": "audio/wav"
+  ".wav": "audio/wav",
+  ".mp4": "video/mp4",
+  ".m4v": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm"
 };
 var ROOT_RUNTIME_PATHS = [
   "/assets/",
@@ -674,7 +679,7 @@ var ROOT_RUNTIME_PATHS = [
   "/spike/",
   "/test-wallpaper.jpg",
   "/preview-sw.js",
-  "/sootsim.svg",
+  "/peach.svg",
   "/bedrock-sqlite.wasm",
   "/bedrock-sqlite.js",
   "/sootsim/"
@@ -758,7 +763,42 @@ function serveRuntimeFile(req, res, fullPath) {
     res.end();
     return;
   }
-  import_fs.default.createReadStream(fullPath).pipe(res);
+  sendFileWithRanges(req, res, fullPath, stat.size, {});
+}
+function sendFileWithRanges(req, res, filePath, total, headers) {
+  const head = (req?.method || "GET").toUpperCase() === "HEAD";
+  const range = /^bytes=(\d*)-(\d*)$/.exec(req?.headers?.range || "");
+  const invalid = range && range[1] && range[2] && Number(range[2]) < Number(range[1]);
+  if (range && (range[1] || range[2]) && !invalid) {
+    const [, startRaw, endRaw] = range;
+    const start = startRaw ? Number(startRaw) : Math.max(0, total - Number(endRaw));
+    const end = startRaw && endRaw ? Math.min(Number(endRaw), total - 1) : total - 1;
+    if (start > end || start >= total) {
+      res.writeHead(416, { ...headers, "Content-Range": `bytes */${total}` });
+      res.end();
+      return;
+    }
+    res.writeHead(206, {
+      ...headers,
+      "Content-Range": `bytes ${start}-${end}/${total}`,
+      "Accept-Ranges": "bytes",
+      "Content-Length": String(end - start + 1)
+    });
+    if (head) res.end();
+    else streamFile(res, import_fs.default.createReadStream(filePath, { start, end }));
+    return;
+  }
+  res.writeHead(200, {
+    ...headers,
+    "Accept-Ranges": "bytes",
+    "Content-Length": String(total)
+  });
+  if (head || total === 0) res.end();
+  else streamFile(res, import_fs.default.createReadStream(filePath, { start: 0, end: total - 1 }));
+}
+function streamFile(res, stream) {
+  stream.on("error", (error) => res.destroy(error));
+  stream.pipe(res);
 }
 
 // src/vite-plugin-one.ts

package/install.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// `npx peachsim` runs the same guided install as
+// `curl -fsSL https://peachsim.com/install.sh | sh`: this package ships that
+// script, and it installs the standalone peach executable, then hands off to
+// `peach setup`.
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const result = spawnSync('sh', [fileURLToPath(new URL('./install.sh', import.meta.url))], {
+  stdio: 'inherit',
+})
+if (result.error) {
+  process.stderr.write(`error: could not run the peach installer: ${result.error.message}\n`)
+  process.exit(1)
+}
+process.exit(result.status ?? 1)

package/install.sh

@@ -0,0 +1,199 @@
+#!/bin/sh
+set -eu
+
+# peach installer
+#
+# this installs the standalone peach executable and hands machine and repository
+# decisions to `peach setup`. it does not require node, bun, npm, or sudo.
+#
+# inspect this entire script without running it:
+#
+#   curl -fsSL https://peachsim.com/install.sh | less
+#
+# install:
+#
+#   curl -fsSL https://peachsim.com/install.sh | sh
+#
+# options:
+#   PEACH_VERSION=0.1.377     install a specific cli version
+#   PEACH_CLI_PREFIX=...      choose the user-writable cli prefix
+#   PEACH_NO_MODIFY_PATH=1    do not update your shell profile
+
+PEACH_VERSION="${PEACH_VERSION:-latest}"
+CLI_PREFIX="${PEACH_CLI_PREFIX:-$HOME/.local}"
+CLI="$CLI_PREFIX/bin/peach"
+RELEASE_ORIGIN="https://r2.rnxsim.com/rnx-cli"
+
+say() {
+  printf '%s\n' "$*"
+}
+
+fail() {
+  printf 'error: %s\n' "$*" >&2
+  exit 1
+}
+
+command_exists() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+command_exists curl || fail "curl is required to install peach"
+
+case "$(uname -s)" in
+  Darwin)
+    PLATFORM="darwin"
+    PLATFORM_LABEL="macOS"
+    ;;
+  Linux)
+    PLATFORM="linux"
+    PLATFORM_LABEL="Linux"
+    ;;
+  *)
+    fail "this installer currently supports macOS and Linux"
+    ;;
+esac
+
+case "$(uname -m)" in
+  arm64 | aarch64)
+    ARCH="arm64"
+    ;;
+  x86_64 | amd64)
+    ARCH="x64"
+    ;;
+  *)
+    fail "peach does not support this processor architecture"
+    ;;
+esac
+
+if [ "$PEACH_VERSION" = "latest" ]; then
+  PEACH_VERSION="$(curl -fsSL "$RELEASE_ORIGIN/channels/stable")" ||
+    fail "could not resolve the current peach version"
+fi
+
+printf '%s' "$PEACH_VERSION" | grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$' ||
+  fail "PEACH_VERSION must be 'latest' or a semantic version"
+
+ARTIFACT="peach-$PLATFORM-$ARCH"
+ARTIFACT_URL="$RELEASE_ORIGIN/$PEACH_VERSION/$ARTIFACT"
+TMP_DIR="$(mktemp -d "${TMPDIR:-/tmp}/peach-install.XXXXXX")"
+TMP_BIN="$TMP_DIR/peach"
+TMP_SHA="$TMP_DIR/peach.sha256"
+cleanup() {
+  rm -rf "$TMP_DIR"
+}
+trap cleanup EXIT HUP INT TERM
+
+say ""
+say "peach installer"
+say ""
+say "  platform: $PLATFORM_LABEL $ARCH"
+say "  version:  $PEACH_VERSION"
+say "  command:  $CLI"
+say ""
+say "Downloading the standalone peach executable..."
+curl -fsSL "$ARTIFACT_URL" -o "$TMP_BIN" || fail "could not download peach"
+curl -fsSL "$ARTIFACT_URL.sha256" -o "$TMP_SHA" ||
+  fail "could not download the peach checksum"
+
+EXPECTED_SHA="$(tr -d '[:space:]' <"$TMP_SHA")"
+printf '%s' "$EXPECTED_SHA" | grep -Eq '^[a-f0-9]{64}$' ||
+  fail "the peach checksum is invalid"
+if [ "$PLATFORM" = "darwin" ]; then
+  ACTUAL_SHA="$(shasum -a 256 "$TMP_BIN" | awk '{print $1}')"
+else
+  ACTUAL_SHA="$(sha256sum "$TMP_BIN" | awk '{print $1}')"
+fi
+[ "$ACTUAL_SHA" = "$EXPECTED_SHA" ] || fail "the peach executable failed verification"
+chmod 755 "$TMP_BIN"
+VERSION_OUTPUT="$("$TMP_BIN" --version 2>/dev/null)" ||
+  fail "the downloaded peach executable did not start"
+REPORTED_VERSION="$(
+  printf '%s\n' "$VERSION_OUTPUT" |
+    sed -n '1s/^peach v\([^[:space:]]*\).*$/\1/p'
+)"
+[ "$REPORTED_VERSION" = "$PEACH_VERSION" ] ||
+  fail "the downloaded peach executable reported the wrong version"
+
+mkdir -p "$CLI_PREFIX/bin"
+NEXT_CLI="$CLI.next.$$"
+cp "$TMP_BIN" "$NEXT_CLI"
+mv -f "$NEXT_CLI" "$CLI"
+
+update_shell_profile() {
+  profile="$1"
+  shell_name="$2"
+  path_line="export PATH=\"$CLI_PREFIX/bin:\$PATH\""
+  integration=""
+  if [ -n "$shell_name" ]; then
+    integration="eval \"\$(command peach __shell-init $shell_name)\""
+  fi
+
+  add_path=0
+  if ! { [ -f "$profile" ] && grep -F "$path_line" "$profile" >/dev/null 2>&1; }; then
+    add_path=1
+  fi
+
+  add_integration=0
+  if [ -n "$integration" ] &&
+    ! { [ -f "$profile" ] && grep -F "$integration" "$profile" >/dev/null 2>&1; }; then
+    add_integration=1
+  fi
+
+  if [ "$add_path" = 0 ] && [ "$add_integration" = 0 ]; then
+    return 0
+  fi
+
+  {
+    printf '\n'
+    printf '# added by the peach installer; delete this block to remove peach from your shell\n'
+    if [ "$add_path" = 1 ]; then
+      printf '%s\n' "$path_line"
+    fi
+    if [ "$add_integration" = 1 ]; then
+      printf '%s\n' "$integration"
+    fi
+  } >>"$profile"
+
+  if [ "$add_path" = 1 ]; then
+    say "Added $CLI_PREFIX/bin to PATH in $profile"
+  fi
+  if [ "$add_integration" = 1 ]; then
+    say "Added Peach shell integration to $profile"
+  fi
+}
+
+if [ "${PEACH_NO_MODIFY_PATH:-0}" = "1" ]; then
+  case ":$PATH:" in
+    *":$CLI_PREFIX/bin:"*) ;;
+    *)
+      say ""
+      say "$CLI_PREFIX/bin is not currently on PATH. Add it with:"
+      say "  export PATH=\"$CLI_PREFIX/bin:\$PATH\""
+      ;;
+  esac
+  case "${SHELL:-}" in
+    */zsh) say "  eval \"\$(command peach __shell-init zsh)\"" ;;
+    */bash) say "  eval \"\$(command peach __shell-init bash)\"" ;;
+  esac
+else
+  case "${SHELL:-}" in
+    */zsh) update_shell_profile "$HOME/.zshrc" zsh ;;
+    */bash) update_shell_profile "$HOME/.bashrc" bash ;;
+    *) update_shell_profile "$HOME/.profile" "" ;;
+  esac
+fi
+
+PATH="$CLI_PREFIX/bin:$PATH"
+export PATH
+
+say ""
+say "peach is installed."
+say ""
+if [ -t 1 ] && [ -r /dev/tty ] && [ -w /dev/tty ]; then
+  say "Continuing with guided setup..."
+  "$CLI" setup </dev/tty
+else
+  say "Run this deterministic setup command in CI:"
+  say ""
+  say "  peach setup --ci --yes --json"
+fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.626",
+  "version": "0.1.628",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -13,6 +13,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "bin": {
+    "peachsim": "./install.mjs"
+  },
   "types": "./src/index.ts",
   "exports": {
     ".": {
@@ -267,6 +270,8 @@
     "./package.json": "./package.json"
   },
   "files": [
+    "install.mjs",
+    "install.sh",
     "dist-lib/",
     "src/",
     "cli/",

package/scripts/dev-server-scanner.ts

@@ -13,7 +13,8 @@
 // zero HTTP requests; probes only fire when a port appears, disappears, or its
 // pid changes. before any HTTP, a TCP connect gate skips unreachable ports.
 
-import { exec } from 'child_process'
+import { spawn } from 'child_process'
+import { terminateProcessGroup } from '../../contrast/src/runtime/process-group'
 import { readlink } from 'fs/promises'
 import http from 'http'
 import net from 'net'
@@ -37,52 +38,66 @@ import {
 import { loadOptionalDemoApps, optionalDemoAppsSync } from './optional-demo-registry.ts'
 import type { AppSettingsSpecifier } from '@peach/globals'
 
-// how long past a command's own budget we wait before deciding its exit event is
-// never coming. generous, because this only fires when the child is already
-// overdue and we are choosing between a wrong answer and a hang.
-const EXEC_EXIT_GRACE_MS = 2_000
-
 /** every subprocess in this file goes through here.
  *
- *  `exec`'s own `timeout` option is NOT a backstop. it kills the child and then
- *  STILL waits for a 'close' event to settle the promise, so when that event is
- *  lost the promise never settles — the timeout is already spent and nothing is
- *  left to rescue it. (same failure m10843 pinned in `CheckoutFilePlane.refresh`.)
- *  `lsof` walks every open fd on the machine, which makes it a realistic victim.
- *
- *  a hung scan is worse than a slow one: `inflightScan` never clears, so
- *  `/__server-scan` stops answering at all instead of answering "could not
- *  look". so we race the child against a real wall-clock deadline and reject
- *  with `killed`, which callers already read as could-not-look. */
-async function execGuarded(
+ *  the command runs under `/bin/sh` as the leader of its own process group, and
+ *  a timeout kills the whole group. `exec`'s own `timeout` kills only the shell:
+ *  for `lsof | grep` that orphans `lsof` to launchd, where it keeps walking every
+ *  open fd on the machine, and a tray rescanning every few seconds on a busy
+ *  host piled up hundreds of them. the deadline is our own timer, so a lost
+ *  'close' event cannot leave the promise unsettled either. a timeout rejects
+ *  with `killed`, which callers read as could-not-look; a non-zero exit rejects
+ *  as `exec` did. */
+function execGuarded(
   command: string,
   timeout: number,
   extra: { maxBuffer?: number } = {},
 ): Promise<{ stdout: string }> {
-  let child: ReturnType<typeof exec> | undefined
-  const ran = new Promise<{ stdout: string }>((resolve, reject) => {
-    child = exec(command, { encoding: 'utf8', timeout, ...extra }, (err, stdout) => {
+  const maxBuffer = extra.maxBuffer ?? 1024 * 1024
+  return new Promise((resolve, reject) => {
+    const child = spawn('/bin/sh', ['-c', command], {
+      detached: true,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+    let stdout = ''
+    let settled = false
+    let killing = false
+    const settle = (err: Error | null) => {
+      if (settled) return
+      settled = true
+      clearTimeout(deadline)
       if (err) reject(err)
       else resolve({ stdout })
+    }
+    // a timeout or an overflow settles only once the whole group is gone.
+    const killThenSettle = (err: Error) => {
+      if (killing) return
+      killing = true
+      clearTimeout(deadline)
+      terminateProcessGroup(child, 'SIGKILL', 0).finally(() => settle(err))
+    }
+    const deadline = setTimeout(() => {
+      killThenSettle(
+        Object.assign(new Error(`\`${command}\` did not exit within ${timeout}ms`), {
+          killed: true,
+        }),
+      )
+    }, timeout)
+    child.stdout.setEncoding('utf8')
+    child.stdout.on('data', (chunk: string) => {
+      stdout += chunk
+      if (stdout.length > maxBuffer) {
+        killThenSettle(new Error(`\`${command}\` exceeded maxBuffer ${maxBuffer}`))
+      }
+    })
+    child.on('error', (err) => {
+      if (!killing) settle(err)
+    })
+    child.on('close', (code) => {
+      if (killing) return
+      settle(code === 0 ? null : new Error(`\`${command}\` exited with ${code}`))
     })
   })
-  let deadlineTimer: ReturnType<typeof setTimeout> | undefined
-  const deadline = new Promise<never>((_resolve, reject) => {
-    deadlineTimer = setTimeout(() => {
-      child?.kill('SIGKILL')
-      const err = new Error(`\`${command}\` did not exit within ${timeout}ms`)
-      // matches the shape `wasKilledByTimeout` reads off a real exec timeout, so
-      // a lost exit event and a genuine timeout reach callers as the same fact.
-      Object.assign(err, { killed: true })
-      reject(err)
-    }, timeout + EXEC_EXIT_GRACE_MS)
-  })
-  try {
-    return await Promise.race([ran, deadline])
-  } finally {
-    // the race is settled, so drop the deadline rather than leaving it pending.
-    clearTimeout(deadlineTimer)
-  }
 }
 
 export interface DiscoveredServer {
@@ -198,6 +213,7 @@ function httpGet(
     // first answer wins: the response, the deadline, and the connection closing
     // all race, and every one of them can arrive after another has decided.
     let settled = false
+    let killing = false
     const settle = (value: HttpResult | null) => {
       if (settled) return
       settled = true
@@ -341,11 +357,32 @@ export async function scanListeningProcesses(
   excludePorts: number[] = [],
 ): Promise<ListeningProcessScan> {
   const excluded = new Set(excludePorts)
+  const listing = await listListenersShared()
+  if (listing.state === 'could-not-look') return listing
+  return {
+    state: 'looked',
+    processes: listing.processes.filter((p) => acceptPort(p.port, excluded)),
+  }
+}
+
+// every caller (the tray's interval, the gateway, the dev middleware, `peach
+// open`) shares one listing while it runs. a scan slower than the tray's
+// interval would otherwise start a second `lsof` on top of the first.
+let inflightListing: Promise<ListeningProcessScan> | null = null
+
+function listListenersShared(): Promise<ListeningProcessScan> {
+  inflightListing ??= listListeners().finally(() => {
+    inflightListing = null
+  })
+  return inflightListing
+}
+
+/** every listening node/bun process, one pid per port, before any port filter. */
+async function listListeners(): Promise<ListeningProcessScan> {
   let timedOut = false
 
   // lsof layout: COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
   // NAME looks like "*:8081" or "127.0.0.1:8081" for a LISTEN line.
-  // async exec — sync blocked CrBrowserMain for ~600ms/scan on macOS.
   try {
     const { stdout } = await execGuarded(
       `lsof -iTCP -sTCP:LISTEN -P -n 2>/dev/null | grep -E '^(node|bun)'`,
@@ -356,11 +393,9 @@ export async function scanListeningProcesses(
       const parts = line.trim().split(/\s+/)
       if (parts.length < 9) continue
       const pid = Number(parts[1])
-      const addr = parts[8]
-      const m = addr.match(/:(\d+)$/)
+      const m = parts[8].match(/:(\d+)$/)
       if (!m) continue
       const port = Number(m[1])
-      if (!acceptPort(port, excluded)) continue
       if (!seen.has(port)) seen.set(port, pid)
     }
     // lsof ran. an empty result is a real answer: nothing is listening.
@@ -385,7 +420,6 @@ export async function scanListeningProcesses(
       if (!portMatch) continue
       const port = Number(portMatch[1])
       const pid = pidMatch ? Number(pidMatch[1]) : 0
-      if (!acceptPort(port, excluded)) continue
       if (!seen.has(port)) seen.set(port, pid)
     }
     return {
@@ -402,10 +436,7 @@ export async function scanListeningProcesses(
 
   // neither tool exists here, so probe the conventional bundler ports directly.
   // that is a real (if narrow) look, not a substitute for one.
-  return {
-    state: 'looked',
-    processes: FALLBACK_PORTS.filter((p) => acceptPort(p.port, excluded)),
-  }
+  return { state: 'looked', processes: FALLBACK_PORTS }
 }
 
 // kept for backwards compatibility with any external callers that only need

package/skills/contrast/SKILL.md

@@ -35,7 +35,7 @@ automation, inspecting the render tree, and managing sims.
 | `peach do` | drive the app (tap, type, scroll, swipe, key, reload, …) |
 | `peach wait` | block until the runtime reaches a known state |
 | `peach shell` | drive shell state and simulator chrome |
-| `peach mode` | toggle screenshot and 3D display modes |
+| `peach mode` | toggle screenshot, touch indicators, and 3D display modes |
 | `peach device` | inspect or change the live device preset for a sim |
 | `peach network` | inspect live network traffic from the running peach worker |
 | `peach logs` | inspect live console output from the running peach worker |

package/src/bridge-constants.ts

@@ -173,3 +173,14 @@ export function isSootsimBridgeHealth(value: unknown, expectedPort: number): boo
 // loop; playwright-owned sims use it to close their hosting context.
 export const SOOTSIM_BRIDGE_SIM_CLOSE_CODE = 4001
 export const SOOTSIM_BRIDGE_SIM_CLOSE_REASON = 'sootsim close'
+
+// automation sims (spawned by the playwright driver: `peach open --driver
+// playwright`, the factory/screenshot capture path, `meta.sootsimHostDriver
+// === 'playwright'`) are unattended browsers, never a human's tab, and an idle
+// one still renders at full rate (the host disables background throttling so
+// captures see real motion). only a cli proves one is in use: attached, which
+// covers a long in-flight command such as a recording, or a command within
+// this window. past it the bridge reaper closes the sim socket with the code
+// above, the page asks its host to close, and the host exits with its chrome
+// tree.
+export const AUTOMATION_SIM_IDLE_REAP_TTL_MS = 5 * 60_000

package/src/capture-contract.ts

@@ -164,6 +164,7 @@ export interface RnxRasterRegionTree {
     nodeId: number
     parentNodeId: number | null
     type: string
+    props?: Record<string, unknown>
     text?: string | null
     style: Record<string, unknown>
     layout: RnxCaptureRect
@@ -173,14 +174,33 @@ export interface RnxRasterRegionTree {
   }[]
 }
 
+function isLiveRasterSource(node: RnxRasterRegionTree['nodes'][number]): boolean {
+  const source = node.props?.source
+  return (
+    node.type === 'image' &&
+    !!source &&
+    typeof source === 'object' &&
+    'uri' in source &&
+    typeof source.uri === 'string' &&
+    source.uri.startsWith('live:')
+  )
+}
+
 export function selectRnxRasterNodeIds(tree: RnxRasterRegionTree): Set<number> {
   const nodesById = new Map(tree.nodes.map((node) => [node.nodeId, node]))
   const unsupported = new Set<number>()
   for (const node of tree.nodes) {
-    const visibleFrame = node.visibleFrame ?? node.frame
+    const liveVideo = isLiveRasterSource(node)
+    const visibleFrame =
+      liveVideo &&
+      node.visibleFrame &&
+      (node.visibleFrame.width <= 0 || node.visibleFrame.height <= 0)
+        ? node.frame
+        : (node.visibleFrame ?? node.frame)
     if (!visibleFrame || visibleFrame.width <= 0 || visibleFrame.height <= 0) continue
     if (
       node.type === 'masked-view' ||
+      liveVideo ||
       (node.type === 'text' &&
         typeof node.text === 'string' &&
         (/\p{Emoji_Presentation}/u.test(node.text) ||
@@ -208,21 +228,33 @@ export function selectRnxRasterNodeIds(tree: RnxRasterRegionTree): Set<number> {
 
   const screenArea = tree.width * tree.height
   const maxLayerArea = screenArea * 0.25
-  const maxAtlasArea = screenArea * 0.5
   const candidates = [...unsupported]
     .map((nodeId) => {
       const node = nodesById.get(nodeId)
-      const frame = node?.visibleFrame ?? node?.frame
-      return frame ? { nodeId, area: frame.width * frame.height } : null
+      if (!node) return null
+      const liveVideo = isLiveRasterSource(node)
+      const frame =
+        liveVideo &&
+        node.visibleFrame &&
+        (node.visibleFrame.width <= 0 || node.visibleFrame.height <= 0)
+          ? node.frame
+          : (node.visibleFrame ?? node.frame)
+      return frame ? { nodeId, area: frame.width * frame.height, liveVideo } : null
     })
     .filter(
-      (candidate): candidate is { nodeId: number; area: number } =>
-        candidate !== null && candidate.area <= maxLayerArea,
+      (candidate): candidate is { nodeId: number; area: number; liveVideo: boolean } =>
+        candidate !== null && (candidate.liveVideo || candidate.area <= maxLayerArea),
+    )
+    .sort(
+      (left, right) =>
+        Number(right.liveVideo) - Number(left.liveVideo) ||
+        left.area - right.area ||
+        left.nodeId - right.nodeId,
     )
-    .sort((left, right) => left.area - right.area || left.nodeId - right.nodeId)
   const selected = new Set<number>()
   let atlasArea = 0
   for (const candidate of candidates) {
+    const maxAtlasArea = screenArea * (candidate.liveVideo ? 1 : 0.5)
     if (atlasArea + candidate.area > maxAtlasArea) continue
     selected.add(candidate.nodeId)
     atlasArea += candidate.area
@@ -345,6 +377,7 @@ export function rnxCaptureRasterRegions(
       nodeId: node.nodeId,
       parentNodeId: node.parentNodeId,
       type: node.type,
+      props: node.props,
       text: node.text,
       style: node.style.resolved,
       layout: node.layout.local,

package/src/dev-bundle-resolution.ts

@@ -20,7 +20,7 @@ export interface ResolvedDevBundle {
 
 function buildUnresolvedTargetError(targetLabel: string): Error {
   return new Error(
-    `could not resolve a native bundle for ${targetLabel}. pass an explicit bundle URL or open Connect and choose the app there.`,
+    `could not resolve a native bundle for ${targetLabel}. start the app's dev server (for example npx expo start), pass an explicit bundle URL, or open Connect and choose the app there.`,
   )
 }