peachsim 0.1.629 → 0.1.630

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.629 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.630 | (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;
@@ -2079,8 +2079,8 @@ var init_capability_inventory_coverage = __esm({
         combined: {
           raw: {
             covered: 7,
-            ratio: 0.00432632880099,
-            total: 1618
+            ratio: 0.00432365657813,
+            total: 1619
           },
           weighted: {
             covered: 118953211737e-15,
@@ -2091,8 +2091,8 @@ var init_capability_inventory_coverage = __esm({
         semantic: {
           raw: {
             covered: 7,
-            ratio: 0.0061295971979,
-            total: 1142
+            ratio: 0.00612423447069,
+            total: 1143
           },
           weighted: {
             covered: 118953211737e-15,
@@ -2118,7 +2118,7 @@ var init_capability_inventory_coverage = __esm({
               raw: {
                 covered: 0,
                 ratio: 0,
-                total: 1419
+                total: 1420
               },
               weighted: {
                 covered: 0,
@@ -2130,7 +2130,7 @@ var init_capability_inventory_coverage = __esm({
               raw: {
                 covered: 0,
                 ratio: 0,
-                total: 990
+                total: 991
               },
               weighted: {
                 covered: 0,
@@ -2154,25 +2154,25 @@ var init_capability_inventory_coverage = __esm({
           ios: {
             combined: {
               raw: {
-                covered: 229,
-                ratio: 0.159248956885,
-                total: 1438
+                covered: 242,
+                ratio: 0.168172341904,
+                total: 1439
               },
               weighted: {
-                covered: 0.5733148295,
-                ratio: 0.125605921087,
+                covered: 0.587946074544,
+                ratio: 0.128811439095,
                 total: 4.56439333862
               }
             },
             semantic: {
               raw: {
-                covered: 229,
-                ratio: 0.224730127576,
-                total: 1019
+                covered: 242,
+                ratio: 0.237254901961,
+                total: 1020
               },
               weighted: {
-                covered: 0.5733148295,
-                ratio: 0.526183631135,
+                covered: 0.587946074544,
+                ratio: 0.539612067396,
                 total: 1.08957176844
               }
             },
@@ -3594,20 +3594,20 @@ var init_capability_outcomes2 = __esm({
               android: {
                 passedWeight: 0,
                 failedWeight: 0,
-                unassessedWeight: 1240,
-                totalWeight: 1240,
+                unassessedWeight: 1241,
+                totalWeight: 1241,
                 assessedWeight: 0,
                 compatibility: null,
                 assessed: 0
               },
               ios: {
-                passedWeight: 176,
+                passedWeight: 175,
                 failedWeight: 0,
-                unassessedWeight: 1075,
-                totalWeight: 1251,
-                assessedWeight: 176,
+                unassessedWeight: 1077,
+                totalWeight: 1252,
+                assessedWeight: 175,
                 compatibility: 1,
-                assessed: 0.14068745003996802
+                assessed: 0.13977635782747605
               }
             },
             usage: {
@@ -3621,22 +3621,19 @@ var init_capability_outcomes2 = __esm({
                 assessed: 0
               },
               ios: {
-                passedWeight: 8041,
+                passedWeight: 7981,
                 failedWeight: 0,
-                unassessedWeight: 24473,
+                unassessedWeight: 24533,
                 totalWeight: 32514,
-                assessedWeight: 8041,
+                assessedWeight: 7981,
                 compatibility: 1,
-                assessed: 0.24730885157163068
+                assessed: 0.2454634926493203
               }
             }
           },
-          capturedAt: "2026-09-25T14:01:15.160Z",
-          receipts: [
-            "core-paired-capture.2026-09-25T14:01:15.160Z.json",
-            "core-paired-capture.2026-09-26T12:47:39.597Z.json"
-          ],
-          sourceCommit: "dbfe444161bb1990b6f3264732e27e103798f5dc"
+          capturedAt: "2026-10-01T07:50:49.727Z",
+          receipts: ["core-paired-capture.2026-10-01T07:50:49.727Z.json"],
+          sourceCommit: "7b3f26ea6413895ef474cf7adcbb130c5eb298c7"
         },
         unmatchedReferenceCount: 7368,
         byPlatform: {
@@ -3664,8 +3661,8 @@ var init_capability_outcomes2 = __esm({
             android: {
               passedWeight: 0,
               failedWeight: 0,
-              unassessedWeight: 1240,
-              totalWeight: 1240,
+              unassessedWeight: 1241,
+              totalWeight: 1241,
               assessedWeight: 0,
               compatibility: null,
               assessed: 0
@@ -3673,8 +3670,8 @@ var init_capability_outcomes2 = __esm({
             ios: {
               passedWeight: 0,
               failedWeight: 0,
-              unassessedWeight: 1251,
-              totalWeight: 1251,
+              unassessedWeight: 1252,
+              totalWeight: 1252,
               assessedWeight: 0,
               compatibility: null,
               assessed: 0
@@ -4404,6 +4401,8 @@ var init_supported_native_packages = __esm({
       // coverage
       "@expo/ui/community/menu",
       // coverage
+      "@fingerprintjs/fingerprintjs-pro-react-native",
+      // seam
       "@fugood/react-native-audio-pcm-stream",
       // seam
       "@fullstory/react-native",
@@ -4512,6 +4511,8 @@ var init_supported_native_packages = __esm({
       // seam
       "@react-native-firebase/functions",
       // seam
+      "@react-native-firebase/messaging",
+      // seam
       "@react-native-firebase/perf",
       // coverage
       "@react-native-firebase/storage",
@@ -4524,6 +4525,8 @@ var init_supported_native_packages = __esm({
       // seam
       "@react-native-picker/picker",
       // seam
+      "@rive-app/react-native",
+      // seam
       "@rn-org/react-native-shortcuts",
       // seam+coverage
       "@rocket.chat/mobile-crypto",
@@ -5196,6 +5199,8 @@ var init_supported_native_packages = __esm({
       // seam
       "react-native-view-pdf",
       // seam
+      "react-native-view-shot",
+      // seam
       "react-native-vision-camera",
       // coverage
       "react-native-vlc-media-player",
@@ -7041,9 +7046,9 @@ var init_registry = __esm({
           {
             range: ">=3.0.0",
             coverage: 0.82,
-            note: "captureRef/captureScreen return REAL captured pixels: the tenant resolves the target node's absolute rect (unstable_getBoundingClientRect), shell routes the native request, and the compositor pixel owner crops + re-encodes that region of the active app surface (createImageBitmap(offscreen, sx,sy,sw,sh) + OffscreenCanvas convertToBlob). The data-uri is coerced into the requested result shape (tmpfile blob URL / base64 / data-uri). validateOptions mirrors upstream src/index.tsx warning text; ViewShot exposes capture() with mount/continuous/update captureMode; releaseCapture revokes tracked blob URLs. When compositor cannot sample the surface (no painted pixels or fully out of bounds), it falls back to a validly-encoded placeholder of the right size so uploads/share/<Image> still get a working result \u2014 one fallback path, no toggle.",
-            working: "captureRef (real pixels of the target subtree region via shell snapshot), captureScreen (full app-surface snapshot), tmpfile/base64/data-uri results, png/jpg/webp formats with quality for lossy, explicit width/height as output dims, validateOptions parity with upstream warning text, ViewShot component with capture() ref method, captureMode mount/continuous/update, releaseCapture revoking tracked blob URLs",
-            missing: "true subtree isolation (the compositor crops a screen rectangle, so an overlapping sibling/overlay inside the bbox is included \u2014 real captureRef renders only the target's hierarchy), presentation-layer transforms (getBoundingClientRect reports the laid-out rect, not an animated/transformed on-screen position), zip-base64 falls back to plain base64, raw format falls back to png, snapshotContentContainer (full scroll content beyond the viewport \u2014 only the painted surface region is available)"
+            note: "captureRef renders only the target view's own subtree, as RNViewShot.mm draws the view alone: the tenant sends the target's view tag, shell routes it to the compositor pixel owner, and the compositor draws that mirror node into an offscreen target at the device scale (drawIsolatedNode), clipped to the view's bounds, so an overlapping sibling or overlay is not in the image. snapshotContentContainer resolves the scroll view (the target or its first scroll view child, else rejects with the native message) and renders its whole content at offset zero. captureScreen crops the whole composited app surface, the keyWindow capture. the real package's JS runs from the bundle (per-platform option validation, ViewShot component, captureMode); the RNViewShot TurboModule seam answers captureRef/captureScreen/releaseCapture. a capture the compositor cannot produce rejects with the native error text; there is no placeholder image.",
+            working: "captureRef (target subtree alone, sibling overlays excluded, clipped to its bounds), snapshotContentContainer (scroll view at full content size, non-scroll target rejects), captureScreen (full app-surface snapshot), tmpfile/base64/data-uri results, png/jpg with quality for jpg (webp on Android), explicit width/height as the drawn output size, upstream option validation, ViewShot component and captureMode (real package JS), releaseCapture revoking tracked blob URLs",
+            missing: "tmpfile results are blob: URLs, not files under NSTemporaryDirectory/ReactNative, useRenderInContext is ignored (the view always scales to the requested size), presentation-layer transforms (getBoundingClientRect reports the laid-out rect, not an animated on-screen position), a content-container capture whose scroll view has no laid-out content rejects with the generic capture error rather than the zero-size message, a content-container capture draws the scroll view background and content but not the scroll view border, opacity, transform or filters (native resizes and draws the scroll view itself), Android zip-base64 falls back to plain base64 and raw to png"
           }
         ]
       },
@@ -7144,10 +7149,60 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=18.0.0",
-            coverage: 0,
-            note: "the reference iOS simulator performs this package's behavior. Peach currently provides only this unsupported shape: development noop : push API surface resolves without real FCM delivery. imports and API shape receive no behavior credit",
-            working: "default messaging(), getToken/deleteToken, requestPermission/hasPermission AUTHORIZED, onMessage/onNotificationOpenedApp/onTokenRefresh subscriptions, getInitialNotification null, setBackgroundMessageHandler, topic subscribe/unsubscribe, auto-init/device registration helpers, AuthorizationStatus constants",
-            missing: "real FCM token, actual message receipt, background handler execution, notification-open events; intentionally absent for browser simulator"
+            note: "native-seam only \u2014 the published @react-native-firebase/messaging JS runs unchanged against a NativeRNFBTurboMessaging seam read from the installed 26.4.0 iOS sources, modeled on the arm64 iOS simulator (never registered for remote notifications). Detox pushes with a gcm.message_id route through the notification bus to onMessage, onNotificationOpenedApp and getInitialNotification like RNFBMessaging+UNUserNotificationCenter. The opened event and one-shot initial notification are read from that native source but have no paired tap proof: on the iOS 27 scene life cycle Detox cannot deliver a tap response to RNFB (a launch tap is dispatched before RNFB installs its center delegate, and a background tap waits for an app delegate applicationDidBecomeActive that never comes). Estimates were reviewed against the installed native source by a second model.",
+            features: [
+              {
+                id: "permission",
+                usage: 3,
+                importance: 3,
+                estimate: 0.9,
+                rationale: "hasPermission and requestPermission map every iOS authorization status like RNFBMessagingModule.mm. Absent: the provisional, announcement, carPlay and providesAppNotificationSettings request options, and the settings-open flag with its messaging_settings_for_notification_opened event."
+              },
+              {
+                id: "foreground-messages",
+                usage: 3,
+                importance: 3,
+                estimate: 0.9,
+                rationale: "onMessage receives a foreground push through the RemoteMessage serializer. Differs: boolean fields such as aps content-available are not converted with RCTConvert BOOL semantics and integer fields use Number rather than intValue, and RNFB's own messaging_ios_foreground_presentation_options and interoperability with another center delegate are not modeled."
+              },
+              {
+                id: "notification-opens",
+                usage: 3,
+                importance: 3,
+                estimate: 1,
+                rationale: "a default-action tap on a push with a gcm.message_id sends messaging_notification_opened and stores a one-shot initial notification, queued until the listener and JS are ready, as RNFBMessaging+UNUserNotificationCenter and RNFBRCTEventEmitter do."
+              },
+              {
+                id: "tokens-and-registration",
+                usage: 3,
+                importance: 3,
+                estimate: 0.9,
+                rationale: "getToken and getAPNSToken reject messaging/unregistered, setAPNSToken reads back upper-case hex, and registerDeviceForRemoteMessages times out after ten seconds, as on the simulator. Absent: the FCM token fetch and onTokenRefresh that native runs after an app supplies an APNs token with setAPNSToken."
+              },
+              {
+                id: "topics-and-token-deletion",
+                usage: 2,
+                importance: 2,
+                estimate: 0,
+                rationale: "deleteToken, subscribeToTopic and unsubscribeFromTopic reject as not available in Peach instead of settling through the FCM backend."
+              },
+              {
+                id: "background-messages",
+                usage: 2,
+                importance: 3,
+                estimate: 0,
+                rationale: "setBackgroundMessageHandler and messaging_message_received_background, the app delegate path for data-only and background pushes, are not implemented."
+              },
+              {
+                id: "auto-init",
+                usage: 1,
+                importance: 1,
+                estimate: 0.5,
+                rationale: "setAutoInitEnabled persists like FIRMessaging. Absent: the FirebaseMessagingAutoInitEnabled Info.plist and data collection defaults native falls back to, and the token request enabling it triggers."
+              }
+            ],
+            working: "hasPermission and requestPermission for ordinary alert, badge, sound and critical alert requests with every iOS authorization status value, onMessage for a foreground push with the RemoteMessage fields (messageId, data, notification title/body/ios fields, category, threadId, contentAvailable), onNotificationOpenedApp and one-shot getInitialNotification from the native delegate source, getToken and getAPNSToken rejecting messaging/unregistered, setAPNSToken with upper-case hex readback, registerDeviceForRemoteMessages rejecting messaging/registration-timeout after ten seconds, constants (isDeviceRegisteredForRemoteMessages false, BigQuery flag), setAutoInitEnabled persistence, sendMessage rejecting as Android-only like iOS",
+            missing: "FCM backend calls: deleteToken, subscribeToTopic and unsubscribeFromTopic reject as not available in Peach instead of settling from the backend; the background handler and messaging_message_received_background; the provisional, announcement, carPlay and providesAppNotificationSettings permission options; setOpenSettingsForNotificationsHandler and the settings-open flag; RNFB's own foreground presentation options and interoperability with another center delegate; RCTConvert BOOL and intValue semantics in the serializer; the FCM token fetch and onTokenRefresh after an app supplies an APNs token; auto-init defaults from Info.plist and data collection; app options: the seeded [DEFAULT] app carries placeholder options rather than the app's GoogleService-Info.plist values, and exists even for an app that never calls FirebaseApp.configure(); onDeletedMessages, onMessageSent and onSendError (Android only)"
           }
         ]
       },
@@ -7809,10 +7864,39 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=50.0.0",
-            coverage: 0.2,
-            note: `unavailable-on-web shape per docs/compat-scoring.md ("keep low unless we add a real browser OAuth flow"): enums and button render, isAvailableAsync returns false, signInAsync/refreshAsync/signOutAsync reject with ERR_NOT_AVAILABLE matching how an unavailable native module behaves. Apps with graceful-degradation paths take the right branch. Returning a fake credential here would lie to consumer code that may try to verify the identityToken against Apple's keys. The 0.2 score is intentional: a real flow requires app-owned Apple ID JS SDK configuration, a Service ID, and an HTTPS redirect, so it cannot be supplied as a generic simulator seam.`,
-            working: "isAvailableAsync (false), AppleAuthenticationButton render (sign in / continue / sign up, WHITE/WHITE_OUTLINE/BLACK styles), all enum exports (Scope, Operation, CredentialState, UserDetectionStatus, ButtonType, ButtonStyle), formatFullName, getCredentialStateAsync (NOT_FOUND), addRevokeListener",
-            missing: "real Sign-in-with-Apple OAuth flow (would need AppleID JS SDK + Service ID + HTTPS)"
+            note: "native-seam only \u2014 the published expo-apple-authentication JS runs unchanged over an ExpoAppleAuthentication module read from the installed iOS sources (AppleAuthenticationModule.swift), modeled on the iOS simulator with no Apple Account signed in, which is what the paired native iPhone 16 run uses.",
+            features: [
+              {
+                id: "availability-and-button",
+                usage: 3,
+                importance: 3,
+                estimate: 1,
+                rationale: "isAvailableAsync resolves true as on iOS, and AppleAuthenticationButton renders every button type and style."
+              },
+              {
+                id: "sign-in",
+                usage: 3,
+                importance: 3,
+                estimate: 0.3,
+                rationale: "signInAsync, refreshAsync and signOutAsync present the Sign in to your Apple Account alert and reject ERR_REQUEST_UNKNOWN when its Close or Settings button is tapped, as a simulator without an Apple Account does, and reject invalid scopes and operations with the native codes; after Settings rejects, Settings comes to the front on its Apple Account sign-in sheet and the app goes inactive then background. Absent: the credential a simulator or device signed in to an Apple Account issues, the sheet hero and device art (private system symbols) and the back-to-app breadcrumb, and the inactive app state while the out-of-process alert is up."
+              },
+              {
+                id: "credential-state",
+                usage: 2,
+                importance: 2,
+                estimate: 1,
+                rationale: "getCredentialStateAsync resolves NOT_FOUND for any user, as a simulator without an Apple Account does; the revoke listener registers and never fires."
+              },
+              {
+                id: "name-formatting",
+                usage: 1,
+                importance: 2,
+                estimate: 0.8,
+                rationale: "formatFullName formats the default, short, medium, long and abbreviated styles as PersonNameComponentsFormatter does on an en_US device for Latin, Cyrillic and Han script names: nickname fallbacks, one-letter given names, grapheme initials, family-first Han order and Han abbreviation by length. An unknown style throws ERR_ARGUMENT_CAST from the Expo bridge. Absent: its rules for kana, Hangul, Thai and mixed-script names and for components that start with a digit or symbol."
+              }
+            ],
+            working: "isAvailableAsync (true), AppleAuthenticationButton render (sign in / continue / sign up, WHITE/WHITE_OUTLINE/BLACK styles), all enum exports, the Sign in to your Apple Account alert for signInAsync, refreshAsync and signOutAsync with ERR_REQUEST_UNKNOWN from Close or Settings, the Settings Apple Account sign-in sheet after Settings, ERR_INVALID_SCOPE and ERR_INVALID_OPERATION, getCredentialStateAsync (NOT_FOUND), formatFullName for Latin, Cyrillic and Han script names on an en_US device, addRevokeListener",
+            missing: "a signed-in Apple Account: no credential, identity token or authorization code is ever issued; the Settings Apple Account sheet has no hero or device art (private system symbols) and no back-to-app breadcrumb; the app stays active while the alert is up where iOS makes it inactive; formatFullName rules for kana, Hangul, Thai and mixed-script names and for components that start with a digit or symbol"
           }
         ]
       },
@@ -9937,10 +10021,23 @@ var init_registry = __esm({
         stubType: "native",
         versions: [
           {
-            range: ">=8.0.0",
-            coverage: 0.6,
-            note: "identical surface to rive-react-native \u2014 the new official package is just a rename. shares the same noop stub",
-            missing: "same as rive-react-native \u2014 no .riv runtime"
+            range: ">=0.4.19 <0.5.0",
+            coverage: 0,
+            note: "native seam: the published Nitro package JavaScript and hooks run unchanged. Rive canvas-advanced uses its C++ WASM core on the host for file parsing, artboard and view model metadata, instance creation, and async scalar data binding. The native view lays out and reports ready; rendering is not built. No visual or playback behavior credit is claimed.",
+            working: "useRiveFile URL, file URL, and byte loading; artboard names/counts; async view model lookup and instance creation; async scalar reads/writes; RiveRuntime initialization; HybridView ref and readiness",
+            missing: "Rive rendering and playback; RiveImage decoding; view binding and state machine inputs/events; referenced asset overrides; nested, trigger, list, image, and artboard binding; synchronous view model operations and scalar reads; instance names; UIKit fallback fonts"
+          }
+        ]
+      },
+      "@fingerprintjs/fingerprintjs-pro-react-native": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=3.17.1 <4.0.0",
+            coverage: 0,
+            note: "native seam only: upstream agent, provider, hooks, and error conversion run unchanged. RNFingerprintjsPro is present and identification calls reject with an explicit UnknownError because the native SDK is unavailable. No visitor identity or identification behavior is claimed.",
+            missing: "FingerprintPro native device signal collection, API transport, visitor identities, extended and sealed responses, and location collection"
           }
         ]
       },
@@ -14375,9 +14472,9 @@ var init_registry = __esm({
           {
             range: ">=0.1.0",
             coverage: 0,
-            note: "getVideoDuration() resolves a hardcoded 0 instead of probing the asset",
-            working: "nothing \u2014 getVideoDuration() resolves a hardcoded 0",
-            missing: "no real AVFoundation duration probe in the simulator"
+            note: "native-seam only: upstream JavaScript reads iOS duration in seconds from real MP4 container metadata; shared parser with expo-video-metadata",
+            working: "iOS getVideoDuration for readable local VFS and HTTP MP4 assets; missing, invalid and unreachable sources resolve zero; published 0.1.2 API exercised",
+            missing: "Android VideoDurationModule, non-MP4 media formats, streaming duration, and native iOS paired evidence"
           }
         ]
       },
@@ -19324,9 +19421,9 @@ function safeChildPlistName(value) {
     name: file.toLowerCase().endsWith(".plist") ? file : `${file}.plist`
   };
 }
-async function readableSettingsBundle(path21) {
+async function readableSettingsBundle(path22) {
   try {
-    const root = await (0, import_promises.stat)((0, import_node_path.join)(path21, "Root.plist"));
+    const root = await (0, import_promises.stat)((0, import_node_path.join)(path22, "Root.plist"));
     return root.isFile() && root.size <= MAX_PLIST_BYTES;
   } catch {
     return false;
@@ -19371,11 +19468,11 @@ async function settingsBundleFingerprint(bundlePath) {
     return null;
   }
 }
-async function parsePlistRecord(path21) {
+async function parsePlistRecord(path22) {
   try {
-    const metadata = await (0, import_promises.stat)(path21);
+    const metadata = await (0, import_promises.stat)(path22);
     if (!metadata.isFile() || metadata.size > MAX_PLIST_BYTES) return null;
-    const source = await (0, import_promises.readFile)(path21, "utf8");
+    const source = await (0, import_promises.readFile)(path22, "utf8");
     const parsed = parsePlistSource(source);
     return isRecord2(parsed) ? parsed : null;
   } catch {
@@ -19699,7 +19796,7 @@ async function tcpPing(port, timeout = TCP_GATE_MS) {
     return null;
   }
 }
-function httpGet(hostname, port, path21, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
+function httpGet(hostname, port, path22, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
   return new Promise((resolve9) => {
     let settled = false;
     let killing = false;
@@ -19708,7 +19805,7 @@ function httpGet(hostname, port, path21, method = "GET", timeout = TIMEOUT_MS, h
       settled = true;
       resolve9(value);
     };
-    const req = import_http.default.request({ hostname, port, path: path21, method, headers }, (res) => {
+    const req = import_http.default.request({ hostname, port, path: path22, method, headers }, (res) => {
       let body = "";
       res.on("data", (c) => body += c.toString());
       const contentType = (() => {
@@ -20357,59 +20454,6 @@ var init_dev_server_scanner = __esm({
   }
 });
 
-// src/public-brand.ts
-var name, peachPublicBrand, rnxPublicBrand;
-var init_public_brand = __esm({
-  "src/public-brand.ts"() {
-    "use strict";
-    name = "Peach";
-    peachPublicBrand = Object.freeze({
-      name,
-      packageName: "peachsim",
-      commandName: "peach",
-      domain: "peachsim.com",
-      origin: "https://peachsim.com"
-    });
-    rnxPublicBrand = peachPublicBrand;
-  }
-});
-
-// src/cli-version.ts
-function getCliVersion() {
-  if (cached2 != null) return cached2;
-  if (typeof __PEACH_CLI_VERSION__ !== "undefined" && typeof __PEACH_CLI_VERSION__ === "string" && __PEACH_CLI_VERSION__) {
-    cached2 = __PEACH_CLI_VERSION__;
-    return cached2;
-  }
-  const candidates = [
-    () => (0, import_node_url2.fileURLToPath)(import_meta.resolve(`${rnxPublicBrand.packageName}/package.json`)),
-    () => (0, import_node_url2.fileURLToPath)(new URL("../package.json", __sootsim_import_meta_url))
-  ];
-  for (const resolve9 of candidates) {
-    try {
-      const version = JSON.parse((0, import_node_fs3.readFileSync)(resolve9(), "utf8")).version;
-      if (typeof version === "string" && version) {
-        cached2 = version;
-        return cached2;
-      }
-    } catch {
-    }
-  }
-  cached2 = "0.0.0";
-  return cached2;
-}
-var import_node_fs3, import_node_url2, import_meta, cached2;
-var init_cli_version = __esm({
-  "src/cli-version.ts"() {
-    "use strict";
-    import_node_fs3 = require("node:fs");
-    import_node_url2 = require("node:url");
-    init_public_brand();
-    import_meta = {};
-    cached2 = null;
-  }
-});
-
 // src/home-paths.ts
 var home_paths_exports = {};
 __export(home_paths_exports, {
@@ -20482,7 +20526,7 @@ function isSootsimDevCheckout() {
   const argv1 = process.argv[1];
   if (!argv1) return false;
   try {
-    const real = import_node_fs4.default.realpathSync(argv1);
+    const real = import_node_fs3.default.realpathSync(argv1);
     return real.includes(`${import_node_path4.default.sep}packages${import_node_path4.default.sep}peachsim${import_node_path4.default.sep}`);
   } catch {
     return false;
@@ -20551,7 +20595,7 @@ function cliUpdateFilePath() {
 }
 function readSharedConfig() {
   try {
-    const raw = import_node_fs4.default.readFileSync(configFilePath(), "utf8");
+    const raw = import_node_fs3.default.readFileSync(configFilePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
@@ -20569,9 +20613,9 @@ function writeSharedConfig(patch) {
     };
   }
   const tmp = `${configFilePath()}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
 `, "utf8");
-  import_node_fs4.default.renameSync(tmp, configFilePath());
+  import_node_fs3.default.renameSync(tmp, configFilePath());
   return next;
 }
 function isOnboardingComplete() {
@@ -20630,14 +20674,14 @@ function runtimeUpgradeNoticePath() {
 function writeRuntimeUpgradeNotice(notice) {
   ensureRnxHome();
   const tmp = `${runtimeUpgradeNoticePath()}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(notice)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(notice)}
 `, "utf8");
-  import_node_fs4.default.renameSync(tmp, runtimeUpgradeNoticePath());
+  import_node_fs3.default.renameSync(tmp, runtimeUpgradeNoticePath());
 }
 function consumeRuntimeUpgradeNotice() {
   try {
-    const raw = import_node_fs4.default.readFileSync(runtimeUpgradeNoticePath(), "utf8");
-    import_node_fs4.default.unlinkSync(runtimeUpgradeNoticePath());
+    const raw = import_node_fs3.default.readFileSync(runtimeUpgradeNoticePath(), "utf8");
+    import_node_fs3.default.unlinkSync(runtimeUpgradeNoticePath());
     const parsed = JSON.parse(raw);
     if (typeof parsed?.to !== "string" || !parsed.to) return null;
     return {
@@ -20650,23 +20694,23 @@ function consumeRuntimeUpgradeNotice() {
   }
 }
 function ensureRnxHome() {
-  import_node_fs4.default.mkdirSync(rnxHomeDir(), { recursive: true });
-  import_node_fs4.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs4.default.mkdirSync(electronDir(), { recursive: true });
-  import_node_fs4.default.mkdirSync(profilesDir(), { recursive: true });
-  import_node_fs4.default.mkdirSync(cacheDir(), { recursive: true });
+  import_node_fs3.default.mkdirSync(rnxHomeDir(), { recursive: true });
+  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs3.default.mkdirSync(electronDir(), { recursive: true });
+  import_node_fs3.default.mkdirSync(profilesDir(), { recursive: true });
+  import_node_fs3.default.mkdirSync(cacheDir(), { recursive: true });
 }
 function readActiveRuntime() {
   try {
-    const value = import_node_fs4.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    const value = import_node_fs3.default.readFileSync(activeRuntimeFile(), "utf8").trim();
     return value.length > 0 ? value : null;
   } catch {
     return null;
   }
 }
 function writeActiveRuntime(version) {
-  import_node_fs4.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs4.default.writeFileSync(activeRuntimeFile(), `${version}
+  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs3.default.writeFileSync(activeRuntimeFile(), `${version}
 `, "utf8");
 }
 function activeRuntimeDir() {
@@ -20674,17 +20718,17 @@ function activeRuntimeDir() {
   if (!version) return null;
   const dir = runtimeDir(version);
   try {
-    if (import_node_fs4.default.statSync(dir).isDirectory()) return dir;
+    if (import_node_fs3.default.statSync(dir).isDirectory()) return dir;
   } catch {
   }
   return null;
 }
 function readDaemonLockfile() {
   try {
-    const fd = import_node_fs4.default.openSync(daemonLockfilePath(), "r");
+    const fd = import_node_fs3.default.openSync(daemonLockfilePath(), "r");
     try {
       const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-      const bytesRead = import_node_fs4.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const bytesRead = import_node_fs3.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
       const raw = buf.subarray(0, bytesRead).toString("utf8");
       const parsed = JSON.parse(raw);
       if (parsed && parsed.schema === 1 && typeof parsed.pid === "number" && typeof parsed.bridgePort === "number" && typeof parsed.runtimePort === "number" && typeof parsed.startedAt === "number" && typeof parsed.heartbeatAt === "number" && (parsed.servedRuntimes === void 0 || Array.isArray(parsed.servedRuntimes) && parsed.servedRuntimes.every((version) => typeof version === "string"))) {
@@ -20692,7 +20736,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs4.default.closeSync(fd);
+      import_node_fs3.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -20712,7 +20756,7 @@ function parseDevBridgeLockfile(raw) {
 function readDevBridgeLockfiles() {
   let entries;
   try {
-    entries = import_node_fs4.default.readdirSync(devBridgesDir(), { withFileTypes: true });
+    entries = import_node_fs3.default.readdirSync(devBridgesDir(), { withFileTypes: true });
   } catch {
     return [];
   }
@@ -20721,10 +20765,10 @@ function readDevBridgeLockfiles() {
     if (!entry.isFile() || !/^\d+\.json$/.test(entry.name)) continue;
     try {
       const filePath = import_node_path4.default.join(devBridgesDir(), entry.name);
-      const fd = import_node_fs4.default.openSync(filePath, "r");
+      const fd = import_node_fs3.default.openSync(filePath, "r");
       try {
         const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-        const bytesRead = import_node_fs4.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+        const bytesRead = import_node_fs3.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
         const lockfile = parseDevBridgeLockfile(
           buf.subarray(0, bytesRead).toString("utf8")
         );
@@ -20732,7 +20776,7 @@ function readDevBridgeLockfiles() {
           lockfiles.push(lockfile);
         }
       } finally {
-        import_node_fs4.default.closeSync(fd);
+        import_node_fs3.default.closeSync(fd);
       }
     } catch {
     }
@@ -20784,28 +20828,28 @@ function writeDaemonLockfile(data) {
     throw new Error("refusing to overwrite another peach daemon lockfile");
   }
   const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
     const current = readDaemonLockfile();
     if (!current || !sameDaemonOwner(current, data)) {
       throw new Error("peach daemon lock ownership changed during heartbeat");
     }
-    import_node_fs4.default.renameSync(tmp, lockfilePath);
+    import_node_fs3.default.renameSync(tmp, lockfilePath);
   } finally {
     try {
-      import_node_fs4.default.unlinkSync(tmp);
+      import_node_fs3.default.unlinkSync(tmp);
     } catch {
     }
   }
 }
 function writeDevBridgeLockfile(data) {
-  import_node_fs4.default.mkdirSync(devBridgesDir(), { recursive: true });
+  import_node_fs3.default.mkdirSync(devBridgesDir(), { recursive: true });
   const lockfilePath = devBridgeLockfilePath(data.bridgePort);
   const tmp = `${lockfilePath}.${data.pid}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs4.default.renameSync(tmp, lockfilePath);
+  import_node_fs3.default.renameSync(tmp, lockfilePath);
 }
 function sameDaemonOwner(left, right) {
   return left.pid === right.pid && left.startedAt === right.startedAt;
@@ -20816,17 +20860,17 @@ function isAlreadyExists(error) {
 function createDaemonLockfileExclusive(data) {
   const lockfilePath = daemonLockfilePath();
   const tmp = `${lockfilePath}.${data.pid}.${(0, import_node_crypto.randomUUID)()}.claim`;
-  import_node_fs4.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    import_node_fs4.default.linkSync(tmp, lockfilePath);
+    import_node_fs3.default.linkSync(tmp, lockfilePath);
     return true;
   } catch (error) {
     if (isAlreadyExists(error)) return false;
     throw error;
   } finally {
     try {
-      import_node_fs4.default.unlinkSync(tmp);
+      import_node_fs3.default.unlinkSync(tmp);
     } catch {
     }
   }
@@ -20850,7 +20894,7 @@ function parseDaemonClaim(raw) {
 }
 function readDaemonClaim() {
   try {
-    return parseDaemonClaim(import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8"));
+    return parseDaemonClaim(import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8"));
   } catch {
     return null;
   }
@@ -20874,7 +20918,7 @@ function acquireDaemonClaim(data) {
 `;
   for (let attempt = 0; attempt < 8; attempt++) {
     try {
-      import_node_fs4.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
+      import_node_fs3.default.writeFileSync(daemonClaimPath(), serialized, { encoding: "utf8", flag: "wx" });
       return true;
     } catch (error) {
       if (!isAlreadyExists(error)) throw error;
@@ -20884,11 +20928,11 @@ function acquireDaemonClaim(data) {
     if (existing && isDaemonClaimFresh(existing)) return false;
     let before;
     try {
-      before = import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8");
+      before = import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8");
       const latest = parseDaemonClaim(before);
       if (latest && isDaemonClaimFresh(latest)) return false;
-      if (import_node_fs4.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
-      import_node_fs4.default.unlinkSync(daemonClaimPath());
+      if (import_node_fs3.default.readFileSync(daemonClaimPath(), "utf8") !== before) continue;
+      import_node_fs3.default.unlinkSync(daemonClaimPath());
     } catch {
     }
   }
@@ -20898,7 +20942,7 @@ function releaseDaemonClaim(owner) {
   try {
     const claim = readDaemonClaim();
     if (!claim || !sameDaemonOwner(claim, owner)) return;
-    import_node_fs4.default.unlinkSync(daemonClaimPath());
+    import_node_fs3.default.unlinkSync(daemonClaimPath());
   } catch {
   }
 }
@@ -20917,7 +20961,7 @@ function claimDaemonLockfile(data) {
       if (!latest || !sameDaemonOwner(latest, existing)) return false;
       if (isDaemonLockfileFresh(latest)) return false;
       try {
-        import_node_fs4.default.unlinkSync(daemonLockfilePath());
+        import_node_fs3.default.unlinkSync(daemonLockfilePath());
       } catch {
         return false;
       }
@@ -20931,25 +20975,25 @@ function removeDaemonLockfile(owner) {
   try {
     const lockfile = readDaemonLockfile();
     if (!lockfile || !sameDaemonOwner(lockfile, owner)) return;
-    import_node_fs4.default.unlinkSync(daemonLockfilePath());
+    import_node_fs3.default.unlinkSync(daemonLockfilePath());
   } catch {
   }
 }
 function removeDevBridgeLockfile(owner) {
   try {
     const lockfilePath = devBridgeLockfilePath(owner.bridgePort);
-    const lockfile = parseDevBridgeLockfile(import_node_fs4.default.readFileSync(lockfilePath, "utf8"));
+    const lockfile = parseDevBridgeLockfile(import_node_fs3.default.readFileSync(lockfilePath, "utf8"));
     if (lockfile?.pid !== owner.pid || lockfile.startedAt !== owner.startedAt) return;
-    import_node_fs4.default.unlinkSync(lockfilePath);
+    import_node_fs3.default.unlinkSync(lockfilePath);
   } catch {
   }
 }
-var import_node_crypto, import_node_fs4, import_node_os, import_node_path4, PEACH_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, CONFIG_FILE, CLI_UPDATE_FILE, DAEMON_HEARTBEAT_STALE_MS, CURRENT_ONBOARDING_VERSION, DAEMON_LOCKFILE_MAX_BYTES, DAEMON_CLAIM_STALE_MS;
+var import_node_crypto, import_node_fs3, import_node_os, import_node_path4, PEACH_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, DEV_BRIDGES_DIR, CONFIG_FILE, CLI_UPDATE_FILE, DAEMON_HEARTBEAT_STALE_MS, CURRENT_ONBOARDING_VERSION, DAEMON_LOCKFILE_MAX_BYTES, DAEMON_CLAIM_STALE_MS;
 var init_home_paths = __esm({
   "src/home-paths.ts"() {
     "use strict";
     import_node_crypto = require("node:crypto");
-    import_node_fs4 = __toESM(require("node:fs"), 1);
+    import_node_fs3 = __toESM(require("node:fs"), 1);
     import_node_os = require("node:os");
     import_node_path4 = __toESM(require("node:path"), 1);
     PEACH_HOME_ENV = "PEACH_HOME";
@@ -20965,19 +21009,87 @@ var init_home_paths = __esm({
   }
 });
 
+// src/automatic-update-policy.ts
+function automaticPeachUpdatesEnabled(env = process.env) {
+  const value = env.PEACH_UPDATE_CHECK?.toLowerCase();
+  return value !== "0" && value !== "false" && value !== "off" && !(0, import_node_fs4.existsSync)((0, import_node_path5.join)(rnxHomeDir(), "runtime-update-disabled"));
+}
+var import_node_fs4, import_node_path5;
+var init_automatic_update_policy = __esm({
+  "src/automatic-update-policy.ts"() {
+    "use strict";
+    import_node_fs4 = require("node:fs");
+    import_node_path5 = require("node:path");
+    init_home_paths();
+  }
+});
+
+// src/public-brand.ts
+var name, peachPublicBrand, rnxPublicBrand;
+var init_public_brand = __esm({
+  "src/public-brand.ts"() {
+    "use strict";
+    name = "Peach";
+    peachPublicBrand = Object.freeze({
+      name,
+      packageName: "peachsim",
+      commandName: "peach",
+      domain: "peachsim.com",
+      origin: "https://peachsim.com"
+    });
+    rnxPublicBrand = peachPublicBrand;
+  }
+});
+
+// src/cli-version.ts
+function getCliVersion() {
+  if (cached2 != null) return cached2;
+  if (typeof __PEACH_CLI_VERSION__ !== "undefined" && typeof __PEACH_CLI_VERSION__ === "string" && __PEACH_CLI_VERSION__) {
+    cached2 = __PEACH_CLI_VERSION__;
+    return cached2;
+  }
+  const candidates = [
+    () => (0, import_node_url2.fileURLToPath)(import_meta.resolve(`${rnxPublicBrand.packageName}/package.json`)),
+    () => (0, import_node_url2.fileURLToPath)(new URL("../package.json", __sootsim_import_meta_url))
+  ];
+  for (const resolve9 of candidates) {
+    try {
+      const version = JSON.parse((0, import_node_fs5.readFileSync)(resolve9(), "utf8")).version;
+      if (typeof version === "string" && version) {
+        cached2 = version;
+        return cached2;
+      }
+    } catch {
+    }
+  }
+  cached2 = "0.0.0";
+  return cached2;
+}
+var import_node_fs5, import_node_url2, import_meta, cached2;
+var init_cli_version = __esm({
+  "src/cli-version.ts"() {
+    "use strict";
+    import_node_fs5 = require("node:fs");
+    import_node_url2 = require("node:url");
+    init_public_brand();
+    import_meta = {};
+    cached2 = null;
+  }
+});
+
 // ../contrast-runtime-delivery/src/product.ts
 function isValidRuntimeVersion(value) {
   return value.length <= 100 && /^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(value);
 }
 function listInstalledRuntimes(product) {
   try {
-    return import_node_fs5.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+    return import_node_fs6.default.readdirSync(product.runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
   } catch {
     return [];
   }
 }
 function runtimeTarballCacheName(product, version) {
-  return import_node_path5.default.posix.basename(product.tarballPath(version));
+  return import_node_path6.default.posix.basename(product.tarballPath(version));
 }
 function compareSemver(a, b) {
   const parse2 = (v) => {
@@ -21000,12 +21112,12 @@ function compareSemver(a, b) {
   if (!bp) return -1;
   return ap < bp ? -1 : 1;
 }
-var import_node_fs5, import_node_path5;
+var import_node_fs6, import_node_path6;
 var init_product = __esm({
   "../contrast-runtime-delivery/src/product.ts"() {
     "use strict";
-    import_node_fs5 = __toESM(require("node:fs"), 1);
-    import_node_path5 = __toESM(require("node:path"), 1);
+    import_node_fs6 = __toESM(require("node:fs"), 1);
+    import_node_path6 = __toESM(require("node:path"), 1);
   }
 });
 
@@ -21014,7 +21126,7 @@ function createRuntimeDelivery(product) {
   function readConfig() {
     try {
       const parsed = JSON.parse(
-        import_node_fs6.default.readFileSync(product.configFile(), "utf8")
+        import_node_fs7.default.readFileSync(product.configFile(), "utf8")
       );
       return parsed && typeof parsed === "object" ? parsed : {};
     } catch {
@@ -21087,7 +21199,7 @@ function createRuntimeDelivery(product) {
     const setActive = opts.setActive !== false;
     const protectVersions = [version, ...opts.protectVersions ?? []];
     pruneLocalRetention({ protectVersions });
-    if (!opts.force && import_node_fs6.default.existsSync(import_node_path6.default.join(destDir, product.installedMarker))) {
+    if (!opts.force && import_node_fs7.default.existsSync(import_node_path7.default.join(destDir, product.installedMarker))) {
       if (setActive) product.writeActiveRuntime(version);
       pruneLocalRetention({ protectVersions });
       return {
@@ -21101,18 +21213,18 @@ function createRuntimeDelivery(product) {
       };
     }
     const tarUrl = entry.tarball || tarballUrl(version, cdnOrigin);
-    const downloadDir = import_node_fs6.default.mkdtempSync(
-      import_node_path6.default.join(import_node_os2.default.tmpdir(), `${product.id}-runtime-download-`)
+    const downloadDir = import_node_fs7.default.mkdtempSync(
+      import_node_path7.default.join(import_node_os2.default.tmpdir(), `${product.id}-runtime-download-`)
     );
-    const runtimeArchivePath = import_node_path6.default.join(
+    const runtimeArchivePath = import_node_path7.default.join(
       downloadDir,
       runtimeTarballCacheName(product, version)
     );
-    const tmpDir = import_node_path6.default.join(
-      import_node_path6.default.dirname(destDir),
+    const tmpDir = import_node_path7.default.join(
+      import_node_path7.default.dirname(destDir),
       `.installing-${version}-${process.pid}`
     );
-    import_node_fs6.default.rmSync(tmpDir, { recursive: true, force: true });
+    import_node_fs7.default.rmSync(tmpDir, { recursive: true, force: true });
     try {
       if (!opts.quiet)
         process.stderr.write(`${product.id}: downloading runtime ${version}\u2026
@@ -21127,20 +21239,20 @@ function createRuntimeDelivery(product) {
           `sha256 mismatch for runtime ${version}: expected ${entry.sha256}, actual ${actualSha}`
         );
       }
-      import_node_fs6.default.mkdirSync(tmpDir, { recursive: true });
+      import_node_fs7.default.mkdirSync(tmpDir, { recursive: true });
       await extractTarball(runtimeArchivePath, tmpDir);
-      if (!import_node_fs6.default.existsSync(import_node_path6.default.join(tmpDir, product.installedMarker))) {
+      if (!import_node_fs7.default.existsSync(import_node_path7.default.join(tmpDir, product.installedMarker))) {
         throw new Error(
           `extracted tarball for runtime ${version} is missing ${product.installedMarker}`
         );
       }
-      import_node_fs6.default.rmSync(destDir, { recursive: true, force: true });
-      import_node_fs6.default.renameSync(tmpDir, destDir);
+      import_node_fs7.default.rmSync(destDir, { recursive: true, force: true });
+      import_node_fs7.default.renameSync(tmpDir, destDir);
     } catch (err) {
-      import_node_fs6.default.rmSync(tmpDir, { recursive: true, force: true });
+      import_node_fs7.default.rmSync(tmpDir, { recursive: true, force: true });
       throw err;
     } finally {
-      import_node_fs6.default.rmSync(downloadDir, { recursive: true, force: true });
+      import_node_fs7.default.rmSync(downloadDir, { recursive: true, force: true });
     }
     if (setActive) product.writeActiveRuntime(version);
     pruneLocalRetention({ protectVersions });
@@ -21162,8 +21274,8 @@ function createRuntimeDelivery(product) {
     const pin = resolvePin();
     if (pin) {
       const activeVersion2 = product.readActiveRuntime();
-      const pinInstalled = import_node_fs6.default.existsSync(
-        import_node_path6.default.join(product.runtimeDir(pin), product.installedMarker)
+      const pinInstalled = import_node_fs7.default.existsSync(
+        import_node_path7.default.join(product.runtimeDir(pin), product.installedMarker)
       );
       if (activeVersion2 === pin && pinInstalled) {
         return {
@@ -21212,7 +21324,7 @@ function createRuntimeDelivery(product) {
     }
     const activeVersion = product.readActiveRuntime();
     const activeDir = activeVersion ? product.runtimeDir(activeVersion) : null;
-    const activeInstalled = activeDir ? import_node_fs6.default.existsSync(import_node_path6.default.join(activeDir, product.installedMarker)) : false;
+    const activeInstalled = activeDir ? import_node_fs7.default.existsSync(import_node_path7.default.join(activeDir, product.installedMarker)) : false;
     const shouldInstall = !activeVersion || !activeInstalled || compareSemver(latestVersion, activeVersion) > 0;
     if (!shouldInstall) {
       return {
@@ -21287,12 +21399,12 @@ function createRuntimeDelivery(product) {
     let removeCacheFiles = [];
     if (markerOffset >= 0) {
       try {
-        removeCacheFiles = import_node_fs6.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
+        removeCacheFiles = import_node_fs7.default.readdirSync(product.cacheDir(), { withFileTypes: true }).filter((entry) => {
           if (!entry.isFile()) return false;
           const complete = entry.name.startsWith(cachePrefix) && entry.name.endsWith(cacheSuffix);
           const partial = entry.name.startsWith(cachePrefix) && entry.name.endsWith(`${cacheSuffix}.partial`);
           return complete || partial;
-        }).map((entry) => import_node_path6.default.join(product.cacheDir(), entry.name)).sort();
+        }).map((entry) => import_node_path7.default.join(product.cacheDir(), entry.name)).sort();
       } catch {
       }
     }
@@ -21307,10 +21419,10 @@ function createRuntimeDelivery(product) {
   function pruneLocalRetention(opts = {}) {
     const plan = planLocalRetention(opts);
     for (const version of plan.removeVersions) {
-      import_node_fs6.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
+      import_node_fs7.default.rmSync(product.runtimeDir(version), { recursive: true, force: true });
     }
     for (const cacheFile of plan.removeCacheFiles) {
-      import_node_fs6.default.rmSync(cacheFile, { force: true });
+      import_node_fs7.default.rmSync(cacheFile, { force: true });
     }
     return plan;
   }
@@ -21336,17 +21448,17 @@ async function downloadToFile(url, destPath) {
   if (!res.ok || !res.body) {
     throw new Error(`download failed: ${res.status} ${res.statusText} (${url})`);
   }
-  import_node_fs6.default.mkdirSync(import_node_path6.default.dirname(destPath), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path7.default.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.partial`;
   try {
     await (0, import_promises3.pipeline)(
       import_node_stream.Readable.fromWeb(res.body),
-      import_node_fs6.default.createWriteStream(tmp)
+      import_node_fs7.default.createWriteStream(tmp)
     );
-    import_node_fs6.default.renameSync(tmp, destPath);
+    import_node_fs7.default.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      import_node_fs6.default.unlinkSync(tmp);
+      import_node_fs7.default.unlinkSync(tmp);
     } catch {
     }
     throw err;
@@ -21355,7 +21467,7 @@ async function downloadToFile(url, destPath) {
 function sha256File(filePath) {
   return new Promise((resolve9, reject) => {
     const hash = import_node_crypto2.default.createHash("sha256");
-    const stream = import_node_fs6.default.createReadStream(filePath);
+    const stream = import_node_fs7.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
     stream.on("end", () => resolve9(hash.digest("hex")));
@@ -21373,15 +21485,15 @@ function extractTarball(tarPath, destDir) {
     });
   });
 }
-var import_node_child_process3, import_node_crypto2, import_node_fs6, import_node_os2, import_node_path6, import_node_stream, import_promises3, DEFAULT_LOCAL_RUNTIME_RETENTION_COUNT;
+var import_node_child_process3, import_node_crypto2, import_node_fs7, import_node_os2, import_node_path7, import_node_stream, import_promises3, DEFAULT_LOCAL_RUNTIME_RETENTION_COUNT;
 var init_src = __esm({
   "../contrast-runtime-delivery/src/index.ts"() {
     "use strict";
     import_node_child_process3 = require("node:child_process");
     import_node_crypto2 = __toESM(require("node:crypto"), 1);
-    import_node_fs6 = __toESM(require("node:fs"), 1);
+    import_node_fs7 = __toESM(require("node:fs"), 1);
     import_node_os2 = __toESM(require("node:os"), 1);
-    import_node_path6 = __toESM(require("node:path"), 1);
+    import_node_path7 = __toESM(require("node:path"), 1);
     import_node_stream = require("node:stream");
     import_promises3 = require("node:stream/promises");
     init_product();
@@ -21557,14 +21669,14 @@ var init_standalone = __esm({
 // cli/self-invocation.ts
 function sourceEntryPath() {
   try {
-    const candidate = (0, import_node_path7.join)((0, import_node_path7.dirname)((0, import_node_url3.fileURLToPath)(__sootsim_import_meta_url)), "bin.ts");
-    return (0, import_node_fs7.existsSync)(candidate) ? candidate : null;
+    const candidate = (0, import_node_path8.join)((0, import_node_path8.dirname)((0, import_node_url3.fileURLToPath)(__sootsim_import_meta_url)), "bin.ts");
+    return (0, import_node_fs8.existsSync)(candidate) ? candidate : null;
   } catch {
     return null;
   }
 }
-function isCliEntry(path21) {
-  const name2 = (0, import_node_path7.basename)(path21);
+function isCliEntry(path22) {
+  const name2 = (0, import_node_path8.basename)(path22);
   return name2 === "bin.ts" || name2 === "bin.js";
 }
 function rnxSelfInvocation() {
@@ -21582,12 +21694,12 @@ function rnxSelfInvocation() {
   }
   return { executable: process.execPath, prefixArgs: [entry] };
 }
-var import_node_fs7, import_node_path7, import_node_url3;
+var import_node_fs8, import_node_path8, import_node_url3;
 var init_self_invocation = __esm({
   "cli/self-invocation.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
-    import_node_path7 = require("node:path");
+    import_node_fs8 = require("node:fs");
+    import_node_path8 = require("node:path");
     import_node_url3 = require("node:url");
     init_public_brand();
     init_standalone();
@@ -21655,7 +21767,7 @@ function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path8.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path9.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -21669,7 +21781,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs8.default.readFileSync(file, "utf8");
+    raw = import_node_fs9.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -21686,7 +21798,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs8.default.renameSync(file, quarantine);
+      import_node_fs9.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -21697,16 +21809,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs8.default.mkdirSync(import_node_path8.default.dirname(file), { recursive: true });
+  import_node_fs9.default.mkdirSync(import_node_path9.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs8.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs9.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs8.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs8.default.fsyncSync(fd);
+    import_node_fs9.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs9.default.fsyncSync(fd);
   } finally {
-    import_node_fs8.default.closeSync(fd);
+    import_node_fs9.default.closeSync(fd);
   }
-  import_node_fs8.default.renameSync(tmp, file);
+  import_node_fs9.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -21715,13 +21827,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto3.createHash)("sha256").update(import_node_path8.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto3.createHash)("sha256").update(import_node_path9.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
   return `s_${(0, import_node_crypto3.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path8.default.resolve(input.cwd);
+  const cwd = import_node_path9.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -21747,7 +21859,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path8.default.basename(cwd),
+      name: input.name ?? import_node_path9.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -21892,8 +22004,8 @@ async function seedFromDemoAppRegistry() {
   if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs8.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path8.default.resolve(app.dir);
+      if (!import_node_fs9.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path9.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -21914,13 +22026,13 @@ async function seedFromDemoAppRegistry() {
     }
   });
 }
-var import_node_crypto3, import_node_fs8, import_node_path8, overrideDir, COST_HISTORY_MAX_AGE_MS;
+var import_node_crypto3, import_node_fs9, import_node_path9, overrideDir, COST_HISTORY_MAX_AGE_MS;
 var init_attached_projects = __esm({
   "src/attached-projects.ts"() {
     "use strict";
     import_node_crypto3 = require("node:crypto");
-    import_node_fs8 = __toESM(require("node:fs"), 1);
-    import_node_path8 = __toESM(require("node:path"), 1);
+    import_node_fs9 = __toESM(require("node:fs"), 1);
+    import_node_path9 = __toESM(require("node:path"), 1);
     init_home_paths();
     overrideDir = null;
     COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
@@ -21929,16 +22041,16 @@ var init_attached_projects = __esm({
 
 // src/agent-sessions.ts
 function sessionDir(sessionId) {
-  return import_node_path9.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path10.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path9.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path10.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path9.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path10.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path9.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path10.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -21948,7 +22060,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs9.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs10.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -21961,11 +22073,11 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path9.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path9.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path10.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path10.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs9.default.existsSync(c)) return { executable: c, prefixArgs: [] };
+        if (import_node_fs10.default.existsSync(c)) return { executable: c, prefixArgs: [] };
       }
     }
   }
@@ -21984,15 +22096,15 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `peach-${process.platform === "win32" ? "windows" : process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`;
-    const distBinary = import_node_path9.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs9.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
-    const distBin = import_node_path9.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs9.default.existsSync(distBin)) {
+    const distBinary = import_node_path10.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs10.default.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] };
+    const distBin = import_node_path10.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs10.default.existsSync(distBin)) {
       try {
-        const src = import_node_path9.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs9.default.existsSync(src)) {
-          const srcMtime = import_node_fs9.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs9.default.statSync(distBin).mtimeMs;
+        const src = import_node_path10.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs10.default.existsSync(src)) {
+          const srcMtime = import_node_fs10.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs10.default.statSync(distBin).mtimeMs;
           if (buildMtime < srcMtime) {
             console.warn(
               `[peach] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/peachsim build:cli\`.`
@@ -22011,22 +22123,22 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve(`${rnxPublicBrand.packageName}/package.json`);
-    return import_node_path9.default.dirname(resolved);
+    return import_node_path10.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path9.default.dirname(here);
+  let cur = import_node_path10.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path9.default.join(cur, "package.json");
+    const pkg = import_node_path10.default.join(cur, "package.json");
     try {
-      if (import_node_fs9.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs9.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs10.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs10.default.readFileSync(pkg, "utf8"));
         if (parsed.name === rnxPublicBrand.packageName) return cur;
       }
     } catch {
     }
-    const parent = import_node_path9.default.dirname(cur);
+    const parent = import_node_path10.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -22042,28 +22154,28 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path9.default.join(getUserDataDir(), "locks");
-  import_node_fs9.default.mkdirSync(lockDir, { recursive: true });
+  const lockDir = import_node_path10.default.join(getUserDataDir(), "locks");
+  import_node_fs10.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs9.default.chmodSync(lockDir, 448);
+    import_node_fs10.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path9.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path10.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs9.default.openSync(
+      fd = import_node_fs10.default.openSync(
         lockPath,
-        import_node_fs9.constants.O_WRONLY | import_node_fs9.constants.O_CREAT | import_node_fs9.constants.O_EXCL,
+        import_node_fs10.constants.O_WRONLY | import_node_fs10.constants.O_CREAT | import_node_fs10.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs9.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs10.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs9.default.unlinkSync(lockPath);
+          import_node_fs10.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -22077,15 +22189,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs9.default.writeFileSync(fd, String(process.pid));
+    import_node_fs10.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs9.default.closeSync(fd);
+      import_node_fs10.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs9.default.unlinkSync(lockPath);
+      import_node_fs10.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -22099,25 +22211,25 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path9.default.dirname(p);
-  import_node_fs9.default.mkdirSync(parent, { recursive: true });
+  const parent = import_node_path10.default.dirname(p);
+  import_node_fs10.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs9.default.chmodSync(parent, 448);
+    import_node_fs10.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs9.default.existsSync(p)) {
+  if (import_node_fs10.default.existsSync(p)) {
     try {
-      const stat2 = import_node_fs9.default.statSync(p);
+      const stat2 = import_node_fs10.default.statSync(p);
       if (stat2.isFIFO()) {
         try {
-          import_node_fs9.default.chmodSync(p, 384);
+          import_node_fs10.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs9.default.unlinkSync(p);
+      import_node_fs10.default.unlinkSync(p);
     } catch {
-      import_node_fs9.default.unlinkSync(p);
+      import_node_fs10.default.unlinkSync(p);
     }
   }
   const result = (0, import_node_child_process4.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -22157,10 +22269,10 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path9.default.dirname(transcript);
-    import_node_fs9.default.mkdirSync(transcriptDir, { recursive: true });
+    const transcriptDir = import_node_path10.default.dirname(transcript);
+    import_node_fs10.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs9.default.chmodSync(transcriptDir, 448);
+      import_node_fs10.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { executable, prefixArgs } = resolveSootsimInvocation();
@@ -22211,7 +22323,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs9.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs10.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -22239,18 +22351,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs9.default.existsSync(fifo)) {
+  if (!import_node_fs10.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_WRONLY);
+  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs9.default.writeSync(fd, wireText + "\n");
+    import_node_fs10.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs9.default.closeSync(fd);
+    import_node_fs10.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -22272,7 +22384,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs9.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs10.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -22280,11 +22392,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs9.default.existsSync(fifo)) {
+  if (!import_node_fs10.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_RDWR);
-  const stream = import_node_fs9.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_RDWR);
+  const stream = import_node_fs10.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -22295,7 +22407,7 @@ function subscribeEvents(sessionId, onEvent) {
     if (closed) return;
     closed = true;
     try {
-      import_node_fs9.default.writeSync(fd, "\n");
+      import_node_fs10.default.writeSync(fd, "\n");
     } catch {
     }
     try {
@@ -22309,7 +22421,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs9.default.openSync(fifo, import_node_fs9.constants.O_RDWR | import_node_fs9.constants.O_NONBLOCK);
+  const fd = import_node_fs10.default.openSync(fifo, import_node_fs10.constants.O_RDWR | import_node_fs10.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -22317,7 +22429,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs9.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs10.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -22337,17 +22449,17 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs9.default.closeSync(fd);
+    import_node_fs10.default.closeSync(fd);
   }
 }
-var import_node_child_process4, import_node_crypto4, import_node_fs9, import_node_path9, import_node_readline, AgentSessionError;
+var import_node_child_process4, import_node_crypto4, import_node_fs10, import_node_path10, import_node_readline, AgentSessionError;
 var init_agent_sessions = __esm({
   "src/agent-sessions.ts"() {
     "use strict";
     import_node_child_process4 = require("node:child_process");
     import_node_crypto4 = require("node:crypto");
-    import_node_fs9 = __toESM(require("node:fs"), 1);
-    import_node_path9 = __toESM(require("node:path"), 1);
+    import_node_fs10 = __toESM(require("node:fs"), 1);
+    import_node_path10 = __toESM(require("node:path"), 1);
     import_node_readline = __toESM(require("node:readline"), 1);
     init_self_invocation();
     init_standalone();
@@ -22378,13 +22490,13 @@ function mapFrameworkToProjectFramework(fw) {
   if (fw === "one" || fw === "vxrn") return "one";
   return "unknown";
 }
-var import_node_crypto5, import_node_fs10, import_node_path10, WS_OPEN, SESSION_STATUS_PERSIST_DELAY_MS, AgentHost;
+var import_node_crypto5, import_node_fs11, import_node_path11, WS_OPEN, SESSION_STATUS_PERSIST_DELAY_MS, AgentHost;
 var init_agent_host = __esm({
   "src/host/agent-host.ts"() {
     "use strict";
     import_node_crypto5 = require("node:crypto");
-    import_node_fs10 = __toESM(require("node:fs"), 1);
-    import_node_path10 = __toESM(require("node:path"), 1);
+    import_node_fs11 = __toESM(require("node:fs"), 1);
+    import_node_path11 = __toESM(require("node:path"), 1);
     init_dev_server_scanner();
     init_agent_sessions();
     init_attached_projects();
@@ -22630,7 +22742,7 @@ var init_agent_host = __esm({
         );
         const project = upsertProject({
           cwd: match.cwd,
-          name: match.projectName ?? import_node_path10.default.basename(match.cwd),
+          name: match.projectName ?? import_node_path11.default.basename(match.cwd),
           preferredProvider: input.provider ?? existing?.preferredProvider,
           sourceRoots: existing?.sourceRoots ?? [match.cwd],
           knownBundleUrls,
@@ -22641,18 +22753,18 @@ var init_agent_host = __esm({
       }
       getTranscript(sessionId) {
         const p = transcriptPath(sessionId);
-        if (!import_node_fs10.default.existsSync(p)) {
+        if (!import_node_fs11.default.existsSync(p)) {
           return { error: "transcript not found", code: "NO_TRANSCRIPT" };
         }
-        return import_node_fs10.default.readFileSync(p, "utf8");
+        return import_node_fs11.default.readFileSync(p, "utf8");
       }
       getPaths() {
         const dir = getUserDataDir();
         return {
           userDataDir: dir,
-          storeFile: import_node_path10.default.join(dir, "attached-projects.json"),
-          sessionsDir: import_node_path10.default.join(dir, "sessions"),
-          transcriptsDir: import_node_path10.default.join(dir, "transcripts")
+          storeFile: import_node_path11.default.join(dir, "attached-projects.json"),
+          sessionsDir: import_node_path11.default.join(dir, "sessions"),
+          transcriptsDir: import_node_path11.default.join(dir, "transcripts")
         };
       }
       // --- subscription management ---
@@ -23502,23 +23614,23 @@ function looksBinary(filePath, size) {
   if (size === 0) return false;
   let fd;
   try {
-    fd = import_node_fs11.default.openSync(filePath, "r");
+    fd = import_node_fs12.default.openSync(filePath, "r");
     const buffer = Buffer.alloc(Math.min(BINARY_SNIFF_BYTES, size));
-    const read = import_node_fs11.default.readSync(fd, buffer, 0, buffer.length, 0);
+    const read = import_node_fs12.default.readSync(fd, buffer, 0, buffer.length, 0);
     return buffer.subarray(0, read).includes(0);
   } catch {
     return false;
   } finally {
-    if (fd !== void 0) import_node_fs11.default.closeSync(fd);
+    if (fd !== void 0) import_node_fs12.default.closeSync(fd);
   }
 }
-var import_node_child_process5, import_node_fs11, import_node_path11, CheckoutRequiresGitError, BINARY_SNIFF_BYTES, LIST_FILES_TIMEOUT_MS, LIST_FILES_ATTEMPTS, LIST_FILES_RETRY_MS, CheckoutFilePlane;
+var import_node_child_process5, import_node_fs12, import_node_path12, CheckoutRequiresGitError, BINARY_SNIFF_BYTES, LIST_FILES_TIMEOUT_MS, LIST_FILES_ATTEMPTS, LIST_FILES_RETRY_MS, CheckoutFilePlane;
 var init_checkout_plane = __esm({
   "cli/commands/box/checkout-plane.ts"() {
     "use strict";
     import_node_child_process5 = require("node:child_process");
-    import_node_fs11 = __toESM(require("node:fs"), 1);
-    import_node_path11 = __toESM(require("node:path"), 1);
+    import_node_fs12 = __toESM(require("node:fs"), 1);
+    import_node_path12 = __toESM(require("node:path"), 1);
     CheckoutRequiresGitError = class extends Error {
     };
     BINARY_SNIFF_BYTES = 8192;
@@ -23535,7 +23647,7 @@ var init_checkout_plane = __esm({
       listTimeoutMs;
       trackedOnly;
       constructor(root, options = {}) {
-        this.root = import_node_path11.default.resolve(root);
+        this.root = import_node_path12.default.resolve(root);
         this.listTimeoutMs = options.listTimeoutMs ?? LIST_FILES_TIMEOUT_MS;
         this.trackedOnly = options.trackedOnly ?? false;
       }
@@ -23597,13 +23709,13 @@ var init_checkout_plane = __esm({
           if (!relative2) continue;
           let stat2;
           try {
-            stat2 = import_node_fs11.default.statSync(import_node_path11.default.join(this.root, relative2));
+            stat2 = import_node_fs12.default.statSync(import_node_path12.default.join(this.root, relative2));
           } catch {
             continue;
           }
           if (!stat2.isFile()) continue;
           const seen = this.sniffed.get(relative2);
-          const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path11.default.join(this.root, relative2), stat2.size);
+          const binary = seen && seen.size === stat2.size && seen.mtimeMs === stat2.mtimeMs ? seen.binary : looksBinary(import_node_path12.default.join(this.root, relative2), stat2.size);
           nextSniffed.set(relative2, { size: stat2.size, mtimeMs: stat2.mtimeMs, binary });
           next.set(relative2, {
             size: stat2.size,
@@ -23617,22 +23729,22 @@ var init_checkout_plane = __esm({
         this.sniffed = nextSniffed;
       }
       absolute(planePath) {
-        const resolved = import_node_path11.default.resolve(this.root, planePath);
-        if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path11.default.sep}`)) {
+        const resolved = import_node_path12.default.resolve(this.root, planePath);
+        if (resolved !== this.root && !resolved.startsWith(`${this.root}${import_node_path12.default.sep}`)) {
           throw new Error(`path escapes the project: ${planePath}`);
         }
         return resolved;
       }
       async read(planePath) {
-        return import_node_fs11.default.promises.readFile(this.absolute(planePath), "utf8");
+        return import_node_fs12.default.promises.readFile(this.absolute(planePath), "utf8");
       }
       async readBytes(planePath) {
-        return import_node_fs11.default.promises.readFile(this.absolute(planePath));
+        return import_node_fs12.default.promises.readFile(this.absolute(planePath));
       }
       async write(planePath, content) {
         const absolute = this.absolute(planePath);
-        await import_node_fs11.default.promises.mkdir(import_node_path11.default.dirname(absolute), { recursive: true });
-        await import_node_fs11.default.promises.writeFile(absolute, content);
+        await import_node_fs12.default.promises.mkdir(import_node_path12.default.dirname(absolute), { recursive: true });
+        await import_node_fs12.default.promises.writeFile(absolute, content);
         this.entries.set(planePath, {
           size: content.byteLength,
           readOnly: false,
@@ -23641,7 +23753,7 @@ var init_checkout_plane = __esm({
         });
       }
       async delete(planePath) {
-        await import_node_fs11.default.promises.rm(this.absolute(planePath), { force: true });
+        await import_node_fs12.default.promises.rm(this.absolute(planePath), { force: true });
         this.entries.delete(planePath);
       }
     };
@@ -23649,12 +23761,12 @@ var init_checkout_plane = __esm({
 });
 
 // src/host/plane-host.ts
-var import_node_fs12, import_node_path12, WS_OPEN2, PlaneNotRegisteredError, PlaneHost;
+var import_node_fs13, import_node_path13, WS_OPEN2, PlaneNotRegisteredError, PlaneHost;
 var init_plane_host = __esm({
   "src/host/plane-host.ts"() {
     "use strict";
-    import_node_fs12 = __toESM(require("node:fs"), 1);
-    import_node_path12 = __toESM(require("node:path"), 1);
+    import_node_fs13 = __toESM(require("node:fs"), 1);
+    import_node_path13 = __toESM(require("node:path"), 1);
     init_plane();
     init_checkout_plane();
     WS_OPEN2 = 1;
@@ -23777,14 +23889,14 @@ var init_plane_host = __esm({
       // root and an opened one cannot disagree about the same directory.
       realRoot(root) {
         if (!root) throw new Error("root is required");
-        const resolved = import_node_path12.default.resolve(root);
+        const resolved = import_node_path13.default.resolve(root);
         let real;
         try {
-          real = import_node_fs12.default.realpathSync(resolved);
+          real = import_node_fs13.default.realpathSync(resolved);
         } catch {
           throw new Error(`no such directory: ${resolved}`);
         }
-        if (!import_node_fs12.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
+        if (!import_node_fs13.default.statSync(real).isDirectory()) throw new Error(`not a directory: ${real}`);
         return real;
       }
       respond(ws, id, result) {
@@ -23835,7 +23947,7 @@ function normalize(p) {
   if (trailingSlash) joined += "/";
   return absolute ? "/" + joined : joined;
 }
-function join4(...parts) {
+function join5(...parts) {
   const present = parts.filter((part) => part.length > 0);
   if (present.length === 0) return ".";
   return normalize(present.join("/"));
@@ -23898,7 +24010,7 @@ var init_posixPath = __esm({
       delimiter,
       isAbsolute,
       normalize,
-      join: join4,
+      join: join5,
       resolve: resolve2,
       dirname: dirname3,
       basename: basename3,
@@ -24166,13 +24278,13 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     res.end("missing path param");
     return true;
   }
-  const extension = import_node_path13.default.extname(targetPath).toLowerCase();
+  const extension = import_node_path14.default.extname(targetPath).toLowerCase();
   if (!REPLACEMENT_MODULE_EXTENSIONS.some((allowed) => allowed === extension)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end(`replacement files must be ${REPLACEMENT_MODULE_EXTENSIONS.join(", ")}`);
     return true;
   }
-  if (!import_node_path13.default.isAbsolute(targetPath)) {
+  if (!import_node_path14.default.isAbsolute(targetPath)) {
     res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
     res.end("replacement file path must be absolute");
     return true;
@@ -24180,10 +24292,10 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   const runtimePackages = new Set(url.searchParams.getAll("runtimePackage"));
   let resolvedProjectRoot;
   if (options.projectRoot) {
-    const lexicalProjectRoot = import_node_path13.default.resolve(options.projectRoot);
+    const lexicalProjectRoot = import_node_path14.default.resolve(options.projectRoot);
     resolvedProjectRoot = await import_promises5.default.realpath(options.projectRoot);
-    const lexicalTarget = import_node_path13.default.relative(lexicalProjectRoot, targetPath);
-    if (lexicalTarget.startsWith("..") || import_node_path13.default.isAbsolute(lexicalTarget)) {
+    const lexicalTarget = import_node_path14.default.relative(lexicalProjectRoot, targetPath);
+    if (lexicalTarget.startsWith("..") || import_node_path14.default.isAbsolute(lexicalTarget)) {
       res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
       res.end("replacement file must be inside the project root");
       return true;
@@ -24199,8 +24311,8 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
     return true;
   }
   if (resolvedProjectRoot) {
-    const relativeTarget = import_node_path13.default.relative(resolvedProjectRoot, resolvedTargetPath);
-    if (relativeTarget.startsWith("..") || import_node_path13.default.isAbsolute(relativeTarget)) {
+    const relativeTarget = import_node_path14.default.relative(resolvedProjectRoot, resolvedTargetPath);
+    if (relativeTarget.startsWith("..") || import_node_path14.default.isAbsolute(relativeTarget)) {
       res.writeHead(403, { "Content-Type": "text/plain; charset=utf-8" });
       res.end("replacement file must be inside the project root");
       return true;
@@ -24227,12 +24339,12 @@ async function handleReplacementModuleRequest(req, res, options = {}) {
   }
   return true;
 }
-var import_promises5, import_node_path13, REPLACEMENT_MODULE_ROUTE;
+var import_promises5, import_node_path14, REPLACEMENT_MODULE_ROUTE;
 var init_replacement_module_handler = __esm({
   "src/host/replacement-module-handler.ts"() {
     "use strict";
     import_promises5 = __toESM(require("node:fs/promises"), 1);
-    import_node_path13 = __toESM(require("node:path"), 1);
+    import_node_path14 = __toESM(require("node:path"), 1);
     init_replacementModule();
     init_backend_origin();
     REPLACEMENT_MODULE_ROUTE = "/__sootsim-replacement-module";
@@ -24518,14 +24630,14 @@ function sharedDesktopAuthAccounts(user) {
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path14.dirname)((0, import_node_path14.resolve)(explicit));
+    return (0, import_node_path15.dirname)((0, import_node_path15.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path14.resolve)(explicit);
-  return (0, import_node_path14.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path15.resolve)(explicit);
+  return (0, import_node_path15.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -24575,26 +24687,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs13.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs14.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs13.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs14.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs13.rmSync)(filepath, { force: true });
+      (0, import_node_fs14.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs13.rmSync)(filepath, { force: true });
+    (0, import_node_fs14.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs13, import_node_path14, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs14, import_node_path15, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs13 = require("node:fs");
-    import_node_path14 = require("node:path");
+    import_node_fs14 = require("node:fs");
+    import_node_path15 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -26402,8 +26514,8 @@ function metroIosAssetDestRelatives(httpServerLocation, filename) {
   }
   const out = [];
   for (const dir of dirs) {
-    const path21 = `${dir}/${filename}`;
-    if (!out.includes(path21)) out.push(path21);
+    const path22 = `${dir}/${filename}`;
+    if (!out.includes(path22)) out.push(path22);
   }
   if (!out.includes(filename)) out.push(filename);
   return out;
@@ -26679,7 +26791,9 @@ async function minify(code, sourceLine, options, withMap) {
   }
   const map = withMap && typeof result.map === "string" ? result.map : null;
   if (withMap && map === null) {
-    throw new Error(`peach Cloud got no source map for the statement at line ${sourceLine}`);
+    throw new Error(
+      `peach Cloud got no source map for the statement at line ${sourceLine}`
+    );
   }
   return { code: result.code.trimEnd(), map, sourceLine };
 }
@@ -26743,8 +26857,9 @@ async function readOrInferModuleIdentity(bundle, mode, inferModuleIdentity) {
 }
 async function buildRnxCloudArtifact(bundle, options = {}) {
   const mode = options.mode ?? "production";
+  const nativeIdentity = (0, import_native_app_identity.detachNativeAppIdentityFooter)(bundle);
   const identity = await readOrInferModuleIdentity(
-    bundle,
+    nativeIdentity.source,
     mode,
     options.inferModuleIdentity
   );
@@ -26770,7 +26885,7 @@ async function buildRnxCloudArtifact(bundle, options = {}) {
     })
   ]);
   const body = pieces.map((piece) => piece.code).join("\n");
-  const code = body + (0, import_metro_production_bundle.createRNXMetroModuleIdentityFooter)({
+  const code = body + (nativeIdentity.identity ? (0, import_native_app_identity.createNativeAppIdentityFooter)(nativeIdentity.identity) : "") + (0, import_metro_production_bundle.createRNXMetroModuleIdentityFooter)({
     version: identity.version,
     identitySource: identity.identitySource,
     modulePaths: identity.modulePaths,
@@ -26833,11 +26948,12 @@ async function buildRnxCloudArtifact(bundle, options = {}) {
     }
   };
 }
-var import_metro_production_bundle, import_terser, MODULE_PATHS_REQUIRED, SOURCE_MAP_REQUIRED, MINIFY_OPTIONS;
+var import_metro_production_bundle, import_native_app_identity, import_terser, MODULE_PATHS_REQUIRED, SOURCE_MAP_REQUIRED, MINIFY_OPTIONS;
 var init_metroCloudArtifact = __esm({
   "../contrast-bundler/src/metroCloudArtifact.ts"() {
     "use strict";
     import_metro_production_bundle = require("peachsim/metro-production-bundle");
+    import_native_app_identity = require("peachsim/native-app-identity");
     import_terser = require("terser");
     init_metroAssetArtifact();
     init_metroDebugSourceMap();
@@ -27066,6 +27182,12 @@ var init_stub_manifest = __esm({
         runtimeTier: "core",
         buildResolvers: ["vite", "dep-prebundle"]
       },
+      vendorEventEmitter: {
+        specifier: "react-native/Libraries/vendor/emitter/EventEmitter",
+        stubFile: "rn-libraries/EventEmitter.ts",
+        runtimeTier: "core",
+        buildResolvers: ["vite", "dep-prebundle"]
+      },
       rctDeviceEventEmitter: {
         specifier: "react-native/Libraries/EventEmitter/RCTDeviceEventEmitter",
         stubFile: "rn-libraries/RCTDeviceEventEmitter.ts",
@@ -27343,13 +27465,13 @@ function readFactoryStringLiterals(factory) {
   return literals;
 }
 function normalizeFingerprintLiteral(literal) {
-  const path21 = literal.replaceAll("\\\\", "/").replaceAll("\\/", "/");
+  const path22 = literal.replaceAll("\\\\", "/").replaceAll("\\/", "/");
   const nodeModulesMarker = "/node_modules/";
-  const nodeModulesIndex = path21.lastIndexOf(nodeModulesMarker);
+  const nodeModulesIndex = path22.lastIndexOf(nodeModulesMarker);
   if (nodeModulesIndex >= 0) {
-    return `node_modules/${path21.slice(nodeModulesIndex + nodeModulesMarker.length)}`;
+    return `node_modules/${path22.slice(nodeModulesIndex + nodeModulesMarker.length)}`;
   }
-  if ((path21.startsWith("/") || /^[A-Za-z]:\//.test(path21) || path21.startsWith("file:/")) && /\.[cm]?[jt]sx?(?::\d+(?::\d+)?)?$/.test(path21)) {
+  if ((path22.startsWith("/") || /^[A-Za-z]:\//.test(path22) || path22.startsWith("file:/")) && /\.[cm]?[jt]sx?(?::\d+(?::\d+)?)?$/.test(path22)) {
     return null;
   }
   return literal;
@@ -27587,10 +27709,10 @@ function templateAssignment(template, embeddings) {
       if (existingNode !== void 0 && existingNode !== nodeIndex) return null;
       nodesByModuleId.set(moduleId, nodeIndex);
       const node = template.nodes[nodeIndex];
-      const path21 = node.landmarkPath ?? `node_modules/${template.packageName}/__rnx_inferred__/${moduleId}.js`;
+      const path22 = node.landmarkPath ?? `node_modules/${template.packageName}/__rnx_inferred__/${moduleId}.js`;
       const existingPath = pathsByModuleId.get(moduleId);
-      if (existingPath !== void 0 && existingPath !== path21) return null;
-      pathsByModuleId.set(moduleId, path21);
+      if (existingPath !== void 0 && existingPath !== path22) return null;
+      pathsByModuleId.set(moduleId, path22);
     }
   }
   return {
@@ -27752,14 +27874,14 @@ async function inferMetroModuleIdentity(args) {
     const packageClaims = claimsByPackage.values().next().value;
     if (!packageClaims) continue;
     const exactClaims = packageClaims.filter((assignment2) => {
-      const path21 = assignment2.pathsByModuleId.get(moduleId);
-      return path21 !== void 0 && !path21.includes("/__rnx_inferred__/");
+      const path22 = assignment2.pathsByModuleId.get(moduleId);
+      return path22 !== void 0 && !path22.includes("/__rnx_inferred__/");
     });
     const preferredClaims = exactClaims.length > 0 ? exactClaims : packageClaims;
     const routes = new Set(
       preferredClaims.flatMap((assignment2) => {
-        const path21 = assignment2.pathsByModuleId.get(moduleId);
-        return path21 ? [metroFingerprintModuleClaimRoute(assignment2.packageName, path21)] : [];
+        const path22 = assignment2.pathsByModuleId.get(moduleId);
+        return path22 ? [metroFingerprintModuleClaimRoute(assignment2.packageName, path22)] : [];
       })
     );
     if (routes.size !== 1) continue;
@@ -28120,21 +28242,21 @@ function resolveCloudOrigin(value) {
   return normalizeCloudOrigin(source);
 }
 function readImmutableBundleSource(bundlePath) {
-  const filepath = (0, import_node_path15.resolve)(bundlePath);
-  if ((0, import_node_path15.extname)(filepath) !== ".js") {
+  const filepath = (0, import_node_path16.resolve)(bundlePath);
+  if ((0, import_node_path16.extname)(filepath) !== ".js") {
     throw new Error(`${REMOTE_COMMAND} requires one local Metro .js bundle`);
   }
-  const descriptor = (0, import_node_fs14.openSync)(filepath, "r");
+  const descriptor = (0, import_node_fs15.openSync)(filepath, "r");
   try {
-    const before = (0, import_node_fs14.fstatSync)(descriptor, { bigint: true });
+    const before = (0, import_node_fs15.fstatSync)(descriptor, { bigint: true });
     if (!before.isFile()) {
       throw new Error(`${REMOTE_COMMAND} bundle must be a regular local file`);
     }
     if (before.size <= 0n) {
       throw new Error(`${REMOTE_COMMAND} bundle is empty`);
     }
-    const bytes = (0, import_node_fs14.readFileSync)(descriptor);
-    const after = (0, import_node_fs14.fstatSync)(descriptor, { bigint: true });
+    const bytes = (0, import_node_fs15.readFileSync)(descriptor);
+    const after = (0, import_node_fs15.fstatSync)(descriptor, { bigint: true });
     if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeNs !== after.mtimeNs || bytes.length !== Number(before.size)) {
       throw new Error(`${REMOTE_COMMAND} bundle changed while it was being read`);
     }
@@ -28149,7 +28271,7 @@ function readImmutableBundleSource(bundlePath) {
     }
     return source;
   } finally {
-    (0, import_node_fs14.closeSync)(descriptor);
+    (0, import_node_fs15.closeSync)(descriptor);
   }
 }
 async function fetchBundleSource(bundleUrl) {
@@ -28196,15 +28318,15 @@ async function loadBundleSource(bundleInput) {
   return readImmutableBundleSource(bundleInput);
 }
 function listMetroAssetDest(assetsPath) {
-  const directory = (0, import_node_path15.resolve)(assetsPath);
-  if (!(0, import_node_fs14.existsSync)(directory)) return { directory, files: [], truncated: false };
-  const skipNested = (0, import_node_fs14.existsSync)((0, import_node_path15.join)(directory, "package.json"));
+  const directory = (0, import_node_path16.resolve)(assetsPath);
+  if (!(0, import_node_fs15.existsSync)(directory)) return { directory, files: [], truncated: false };
+  const skipNested = (0, import_node_fs15.existsSync)((0, import_node_path16.join)(directory, "package.json"));
   const files = [];
   let truncated = false;
   const walk = (dir, prefix) => {
     let entries;
     try {
-      entries = (0, import_node_fs14.readdirSync)(dir, { withFileTypes: true });
+      entries = (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -28216,7 +28338,7 @@ function listMetroAssetDest(assetsPath) {
       if (entry.isDirectory()) {
         if (entry.name === ".git") continue;
         if (skipNested && PROJECT_ONLY_DIRECTORIES.has(entry.name)) continue;
-        walk((0, import_node_path15.join)(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
+        walk((0, import_node_path16.join)(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name);
       } else if (entry.isFile()) {
         files.push(prefix ? `${prefix}/${entry.name}` : entry.name);
       }
@@ -28251,7 +28373,7 @@ function distinctByContent(directory, options) {
   for (const relative2 of options) {
     let bytes;
     try {
-      bytes = (0, import_node_fs14.readFileSync)((0, import_node_path15.join)(directory, relative2));
+      bytes = (0, import_node_fs15.readFileSync)((0, import_node_path16.join)(directory, relative2));
     } catch {
       continue;
     }
@@ -28283,7 +28405,7 @@ function placeMetroDescriptor(listing, descriptor) {
     let bytes;
     try {
       bytes = combination.map(
-        (relative2) => (0, import_node_fs14.readFileSync)((0, import_node_path15.join)(listing.directory, relative2))
+        (relative2) => (0, import_node_fs15.readFileSync)((0, import_node_path16.join)(listing.directory, relative2))
       );
     } catch {
       continue;
@@ -28309,26 +28431,26 @@ function placeMetroDescriptor(listing, descriptor) {
 }
 function unverifiedFileKey(dest) {
   return dest.placements.filter((placement) => !placement.verified).flatMap(
-    (placement) => [...placement.files.values()].map((relative2) => (0, import_node_path15.join)(dest.directory, relative2))
+    (placement) => [...placement.files.values()].map((relative2) => (0, import_node_path16.join)(dest.directory, relative2))
   ).sort().join("\n");
 }
 function searchMetroAssetDest(bundlePath, descriptors) {
-  const bundleDirectory = (0, import_node_path15.dirname)((0, import_node_path15.resolve)(bundlePath));
+  const bundleDirectory = (0, import_node_path16.dirname)((0, import_node_path16.resolve)(bundlePath));
   const candidates = [
-    (0, import_node_path15.join)(bundleDirectory, "assets"),
+    (0, import_node_path16.join)(bundleDirectory, "assets"),
     bundleDirectory,
-    (0, import_node_path15.resolve)(bundleDirectory, "..", "assets")
+    (0, import_node_path16.resolve)(bundleDirectory, "..", "assets")
   ];
   const cwd = process.cwd();
   let projectDirectory = null;
   for (const start of [bundleDirectory, cwd]) {
-    let directory = (0, import_node_path15.resolve)(start);
+    let directory = (0, import_node_path16.resolve)(start);
     while (true) {
       if (detectProject(directory)?.hasMetroConfig) {
         projectDirectory = directory;
         break;
       }
-      const parent = (0, import_node_path15.dirname)(directory);
+      const parent = (0, import_node_path16.dirname)(directory);
       if (parent === directory) break;
       directory = parent;
     }
@@ -28336,11 +28458,11 @@ function searchMetroAssetDest(bundlePath, descriptors) {
   }
   if (projectDirectory) {
     candidates.push(
-      (0, import_node_path15.join)(projectDirectory, "assets"),
-      (0, import_node_path15.join)(projectDirectory, "dist"),
-      (0, import_node_path15.join)(projectDirectory, "dist", "assets"),
-      (0, import_node_path15.join)(projectDirectory, "build"),
-      (0, import_node_path15.join)(projectDirectory, "build", "assets")
+      (0, import_node_path16.join)(projectDirectory, "assets"),
+      (0, import_node_path16.join)(projectDirectory, "dist"),
+      (0, import_node_path16.join)(projectDirectory, "dist", "assets"),
+      (0, import_node_path16.join)(projectDirectory, "build"),
+      (0, import_node_path16.join)(projectDirectory, "build", "assets")
     );
   }
   const searched = [];
@@ -28348,7 +28470,7 @@ function searchMetroAssetDest(bundlePath, descriptors) {
   const stale = [];
   let truncated = false;
   for (const candidate of candidates) {
-    const directory = (0, import_node_path15.resolve)(candidate);
+    const directory = (0, import_node_path16.resolve)(candidate);
     if (searched.includes(directory)) continue;
     searched.push(directory);
     const listing = listMetroAssetDest(directory);
@@ -28454,7 +28576,7 @@ async function embedBundleAssets(bundlePath, command, assetPolicy) {
       );
     }
     const relative2 = placement?.files.get(variant.scale);
-    if (relative2 && dest) return (0, import_node_fs14.readFileSync)((0, import_node_path15.join)(dest.directory, relative2));
+    if (relative2 && dest) return (0, import_node_fs15.readFileSync)((0, import_node_path16.join)(dest.directory, relative2));
     if (placement && placement.files.size > 0) return null;
     if (placement && placement.ambiguous.length > 0 && dest) {
       throw new Error(
@@ -28483,7 +28605,7 @@ async function embedBundleAssets(bundlePath, command, assetPolicy) {
     );
     const classic = metroIosAssetDestRelatives(variant.descriptor.httpServerLocation, filename)[0] ?? filename;
     throw new Error(
-      `${command} could not read ${(0, import_node_path15.join)(dest?.directory ?? ".", classic)} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}, and has no stand-in for a .${variant.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`
+      `${command} could not read ${(0, import_node_path16.join)(dest?.directory ?? ".", classic)} for ${variant.descriptor.name}.${variant.descriptor.type} at scale ${variant.scale}, and has no stand-in for a .${variant.descriptor.type} asset. Rebuild with \`react-native bundle --assets-dest\`.`
     );
   });
   return {
@@ -28669,13 +28791,13 @@ function createCloudBridgeForParsed(parsed) {
   if (!session) return null;
   return session.service === "box" ? new CloudBoxBridge(session) : new CloudBridge(session);
 }
-var import_node_crypto6, import_node_fs14, import_node_path15, DEFAULT_RNX_CLOUD_ORIGIN, MAX_RNX_CLOUD_BUNDLE_BYTES, REMOTE_COMMAND, MAX_ASSET_DEST_FILES, ACCOUNT_CHOICE_REFUSALS, PROJECT_ONLY_DIRECTORIES, MAX_PLACEMENT_COMBINATIONS, CloudBridge, CloudBoxBridge;
+var import_node_crypto6, import_node_fs15, import_node_path16, DEFAULT_RNX_CLOUD_ORIGIN, MAX_RNX_CLOUD_BUNDLE_BYTES, REMOTE_COMMAND, MAX_ASSET_DEST_FILES, ACCOUNT_CHOICE_REFUSALS, PROJECT_ONLY_DIRECTORIES, MAX_PLACEMENT_COMBINATIONS, CloudBridge, CloudBoxBridge;
 var init_cloud_client = __esm({
   "cli/cloud-client.ts"() {
     "use strict";
     import_node_crypto6 = require("node:crypto");
-    import_node_fs14 = require("node:fs");
-    import_node_path15 = require("node:path");
+    import_node_fs15 = require("node:fs");
+    import_node_path16 = require("node:path");
     init_metroAssetArtifact();
     init_metroCloudArtifact();
     init_metro_fingerprint_registry_client();
@@ -28957,6 +29079,7 @@ var init_bridge_host = __esm({
     import_ws = require("ws");
     init_dev_server_scanner();
     init_backend_origin();
+    init_automatic_update_policy();
     init_bridge_constants();
     init_cli_version();
     init_home_paths();
@@ -29830,7 +29953,7 @@ var init_bridge_host = __esm({
       }
       startRuntimeUpdater() {
         if (!this.shouldWriteLockfile || this.runtimeUpdateTimer) return;
-        if (import_fs3.default.existsSync(import_path3.default.join(rnxHomeDir(), "runtime-update-disabled"))) {
+        if (!automaticPeachUpdatesEnabled()) {
           this.bootstrapping = false;
           if (this.httpServer) this.writeLockfileSnapshot();
           return;
@@ -29846,6 +29969,7 @@ var init_bridge_host = __esm({
         this.runtimeUpdateTimer.unref();
       }
       runRuntimeUpdate(reason) {
+        if (!automaticPeachUpdatesEnabled()) return Promise.resolve();
         if (this.runtimeUpdateInFlight) return this.runtimeUpdateInFlight;
         this.runtimeUpdateInFlight = (async () => {
           try {
@@ -31083,31 +31207,31 @@ var init_parent_pid = __esm({
 
 // cli/secure-file.ts
 function writeSecureJsonAtomic(filepath, value) {
-  (0, import_node_fs15.mkdirSync)((0, import_node_path16.dirname)(filepath), { recursive: true });
+  (0, import_node_fs16.mkdirSync)((0, import_node_path17.dirname)(filepath), { recursive: true });
   const temporary = `${filepath}.tmp-${process.pid}-${(0, import_node_crypto7.randomUUID)()}`;
   let descriptor = null;
   try {
-    descriptor = (0, import_node_fs15.openSync)(temporary, "wx", 384);
-    (0, import_node_fs15.fchmodSync)(descriptor, 384);
-    (0, import_node_fs15.writeFileSync)(descriptor, `${JSON.stringify(value, null, 2)}
+    descriptor = (0, import_node_fs16.openSync)(temporary, "wx", 384);
+    (0, import_node_fs16.fchmodSync)(descriptor, 384);
+    (0, import_node_fs16.writeFileSync)(descriptor, `${JSON.stringify(value, null, 2)}
 `);
-    (0, import_node_fs15.fsyncSync)(descriptor);
-    (0, import_node_fs15.closeSync)(descriptor);
+    (0, import_node_fs16.fsyncSync)(descriptor);
+    (0, import_node_fs16.closeSync)(descriptor);
     descriptor = null;
-    (0, import_node_fs15.renameSync)(temporary, filepath);
+    (0, import_node_fs16.renameSync)(temporary, filepath);
   } catch (error) {
-    if (descriptor !== null) (0, import_node_fs15.closeSync)(descriptor);
-    (0, import_node_fs15.rmSync)(temporary, { force: true });
+    if (descriptor !== null) (0, import_node_fs16.closeSync)(descriptor);
+    (0, import_node_fs16.rmSync)(temporary, { force: true });
     throw error;
   }
 }
-var import_node_crypto7, import_node_fs15, import_node_path16;
+var import_node_crypto7, import_node_fs16, import_node_path17;
 var init_secure_file = __esm({
   "cli/secure-file.ts"() {
     "use strict";
     import_node_crypto7 = require("node:crypto");
-    import_node_fs15 = require("node:fs");
-    import_node_path16 = require("node:path");
+    import_node_fs16 = require("node:fs");
+    import_node_path17 = require("node:path");
   }
 });
 
@@ -31282,17 +31406,17 @@ function liveDevBridgeLockfiles() {
   return readDevBridgeLockfiles().filter((lockfile) => isDevBridgeLockfileFresh(lockfile));
 }
 function checkoutRoot(cwd) {
-  let current = import_node_path17.default.resolve(cwd);
+  let current = import_node_path18.default.resolve(cwd);
   while (true) {
-    if (import_node_fs16.default.existsSync(import_node_path17.default.join(current, ".git"))) return current;
-    const parent = import_node_path17.default.dirname(current);
+    if (import_node_fs17.default.existsSync(import_node_path18.default.join(current, ".git"))) return current;
+    const parent = import_node_path18.default.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
 }
 function pathContains(parent, child) {
-  const relative2 = import_node_path17.default.relative(parent, child);
-  return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${import_node_path17.default.sep}`) && !import_node_path17.default.isAbsolute(relative2);
+  const relative2 = import_node_path18.default.relative(parent, child);
+  return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${import_node_path18.default.sep}`) && !import_node_path18.default.isAbsolute(relative2);
 }
 function resolveDefaultDevBridgeLockfile() {
   const lockfiles = liveDevBridgeLockfiles();
@@ -31784,18 +31908,18 @@ async function evalInBridge(bridge, code, opts = {}) {
   if (opts.acquireLock) payload.acquireLock = true;
   return bridge.send(payload);
 }
-async function callInBridge(bridge, path21, ...args) {
-  return bridge.send({ type: "call", path: path21, args });
+async function callInBridge(bridge, path22, ...args) {
+  return bridge.send({ type: "call", path: path22, args });
 }
-async function callInBridgeWrite(bridge, path21, ...args) {
-  return bridge.send({ type: "call", path: path21, args, acquireLock: true });
+async function callInBridgeWrite(bridge, path22, ...args) {
+  return bridge.send({ type: "call", path: path22, args, acquireLock: true });
 }
-var import_node_fs16, import_node_path17, import_ws2, PEACH_PLACEMENT_ENV, resolvedWorld, BridgeSimLockedError, BRIDGE_VALUE_FLAGS_TABLE, BRIDGE_VALUE_FLAGS;
+var import_node_fs17, import_node_path18, import_ws2, PEACH_PLACEMENT_ENV, resolvedWorld, BridgeSimLockedError, BRIDGE_VALUE_FLAGS_TABLE, BRIDGE_VALUE_FLAGS;
 var init_ws_bridge = __esm({
   "cli/ws-bridge.ts"() {
     "use strict";
-    import_node_fs16 = __toESM(require("node:fs"), 1);
-    import_node_path17 = __toESM(require("node:path"), 1);
+    import_node_fs17 = __toESM(require("node:fs"), 1);
+    import_node_path18 = __toESM(require("node:path"), 1);
     import_ws2 = require("ws");
     init_bridge_constants();
     init_cli_constants();
@@ -31923,8 +32047,8 @@ function getDefaultPortForProtocol(protocol) {
   return protocol === "https:" ? 443 : 80;
 }
 function isBaseServerUrl(url) {
-  const path21 = url.pathname || "/";
-  return (path21 === "/" || path21 === "") && !url.search && !url.hash;
+  const path22 = url.pathname || "/";
+  return (path22 === "/" || path22 === "") && !url.search && !url.hash;
 }
 async function resolvePortViaServerScan(port) {
   try {
@@ -32098,6 +32222,96 @@ var init_flow_timeout_scale = __esm({
   }
 });
 
+// src/native-firebase-config.ts
+function readNativeFirebaseConfig(projectRoot) {
+  const result = {};
+  if (![
+    "app.json",
+    "app.config.js",
+    "app.config.ts",
+    "app.config.cjs",
+    "app.config.mjs"
+  ].some((name2) => import_node_fs18.default.existsSync(import_node_path19.default.join(projectRoot, name2))))
+    return result;
+  const require5 = (0, import_node_module.createRequire)(import_node_path19.default.join(projectRoot, "package.json"));
+  const configModule = require5("@expo/config");
+  if (!isRecord(configModule) || typeof configModule.getConfig !== "function") {
+    throw new Error("Expo native configuration is unavailable.");
+  }
+  const resolved = Reflect.apply(configModule.getConfig, configModule, [
+    projectRoot,
+    { skipSDKVersionRequirement: true }
+  ]);
+  const config = isRecord(resolved) && isRecord(resolved.exp) ? resolved.exp : {};
+  for (const platform of ["ios", "android"]) {
+    const native = config[platform];
+    if (!isRecord(native) || typeof native.googleServicesFile !== "string") continue;
+    try {
+      const source = import_node_fs18.default.readFileSync(
+        import_node_path19.default.resolve(projectRoot, native.googleServicesFile),
+        "utf8"
+      );
+      const parsed = platform === "ios" ? parsePlistSource(source) : JSON.parse(source);
+      if (!isRecord(parsed)) throw new Error("Invalid Google services file.");
+      if (platform === "ios") {
+        result[platform] = {
+          apiKey: parsed.API_KEY,
+          appId: parsed.GOOGLE_APP_ID,
+          projectId: parsed.PROJECT_ID,
+          databaseURL: parsed.DATABASE_URL,
+          gaTrackingId: parsed.TRACKING_ID,
+          storageBucket: parsed.STORAGE_BUCKET,
+          messagingSenderId: parsed.GCM_SENDER_ID,
+          clientId: parsed.CLIENT_ID,
+          androidClientID: parsed.ANDROID_CLIENT_ID,
+          deepLinkUrlScheme: parsed.REVERSED_CLIENT_ID
+        };
+      } else {
+        const project = isRecord(parsed.project_info) ? parsed.project_info : {};
+        const clients = Array.isArray(parsed.client) ? parsed.client : [];
+        const client = clients.find((value) => {
+          if (!isRecord(value) || !isRecord(value.client_info)) return false;
+          const android = value.client_info.android_client_info;
+          return isRecord(android) && android.package_name === native.package;
+        });
+        if (!isRecord(client) || !isRecord(client.client_info))
+          throw new Error("No Google services client matches the Android package.");
+        const apiKeys = Array.isArray(client.api_key) ? client.api_key : [];
+        const apiKey = apiKeys.find(
+          (value) => isRecord(value) && typeof value.current_key === "string"
+        );
+        const oauthClients = Array.isArray(client.oauth_client) ? client.oauth_client : [];
+        const oauth = oauthClients.find(
+          (value) => isRecord(value) && value.client_type === 3
+        );
+        result[platform] = {
+          apiKey: isRecord(apiKey) ? apiKey.current_key : void 0,
+          appId: client.client_info.mobilesdk_app_id,
+          projectId: project.project_id,
+          databaseURL: project.firebase_url,
+          storageBucket: project.storage_bucket,
+          messagingSenderId: project.project_number,
+          clientId: isRecord(oauth) ? oauth.client_id : void 0
+        };
+      }
+    } catch (error) {
+      result[platform] = { error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  return result;
+}
+var import_node_fs18, import_node_module, import_node_path19;
+var init_native_firebase_config = __esm({
+  "src/native-firebase-config.ts"() {
+    "use strict";
+    import_node_fs18 = __toESM(require("node:fs"), 1);
+    import_node_module = require("node:module");
+    import_node_path19 = __toESM(require("node:path"), 1);
+    init_is_record();
+    init_plist();
+  }
+});
+
 // src/profiles.ts
 function normalizeProfileId(input) {
   const id = input.trim();
@@ -32256,7 +32470,7 @@ function colorsetValue(color) {
 }
 function enumerateBundleColors(paths, readText2) {
   const table = {};
-  for (const contentsPath of paths.filter((path21) => baseOf(path21) === "Contents.json")) {
+  for (const contentsPath of paths.filter((path22) => baseOf(path22) === "Contents.json")) {
     const name2 = catalogEntryName(contentsPath, ".colorset", readText2);
     if (name2 === null || name2 in table) continue;
     let colors;
@@ -32304,59 +32518,59 @@ var init_bundleAssets = __esm({
 // cli/app-catalog.ts
 function listDir(dir) {
   try {
-    return import_node_fs17.default.readdirSync(dir, { withFileTypes: true });
+    return import_node_fs19.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
 }
 function readText(file) {
   try {
-    return import_node_fs17.default.readFileSync(file, "utf8");
+    return import_node_fs19.default.readFileSync(file, "utf8");
   } catch {
     return null;
   }
 }
 function catalogFiles(dir, found) {
   for (const entry of listDir(dir)) {
-    const full = import_node_path18.default.join(dir, entry.name);
+    const full = import_node_path20.default.join(dir, entry.name);
     if (entry.isDirectory()) catalogFiles(full, found);
     else if (entry.name === "Contents.json") found.push(full);
   }
 }
 function discoverAppCatalog(appDir) {
-  const iosDir = import_node_path18.default.join(appDir, "ios");
+  const iosDir = import_node_path20.default.join(appDir, "ios");
   const target = listDir(iosDir).find(
-    (entry) => entry.isDirectory() && entry.name !== "Pods" && listDir(import_node_path18.default.join(iosDir, entry.name)).some(
+    (entry) => entry.isDirectory() && entry.name !== "Pods" && listDir(import_node_path20.default.join(iosDir, entry.name)).some(
       (file) => /^AppDelegate\.(swift|mm|m)$/.test(file.name)
     )
   );
   if (!target) return null;
-  const targetDir = import_node_path18.default.join(iosDir, target.name);
+  const targetDir = import_node_path20.default.join(iosDir, target.name);
   const files = [];
   for (const entry of listDir(targetDir)) {
     if (entry.isDirectory() && entry.name.endsWith(".xcassets"))
-      catalogFiles(import_node_path18.default.join(targetDir, entry.name), files);
+      catalogFiles(import_node_path20.default.join(targetDir, entry.name), files);
   }
   const relative2 = files.map(
-    (file) => import_node_path18.default.relative(targetDir, file).split(import_node_path18.default.sep).join(import_node_path18.default.posix.sep)
+    (file) => import_node_path20.default.relative(targetDir, file).split(import_node_path20.default.sep).join(import_node_path20.default.posix.sep)
   );
   const colors = enumerateBundleColors(
     relative2,
-    (candidate) => candidate.endsWith("Contents.json") ? readText(import_node_path18.default.join(targetDir, candidate)) : null
+    (candidate) => candidate.endsWith("Contents.json") ? readText(import_node_path20.default.join(targetDir, candidate)) : null
   );
   const pbxproj = listDir(iosDir).find((entry) => entry.name.endsWith(".xcodeproj"));
-  const accentName = readText(import_node_path18.default.join(targetDir, "Info.plist"))?.match(PLIST_ACCENT)?.[1] ?? (pbxproj ? readText(import_node_path18.default.join(iosDir, pbxproj.name, "project.pbxproj"))?.match(
+  const accentName = readText(import_node_path20.default.join(targetDir, "Info.plist"))?.match(PLIST_ACCENT)?.[1] ?? (pbxproj ? readText(import_node_path20.default.join(iosDir, pbxproj.name, "project.pbxproj"))?.match(
     ACCENT_BUILD_SETTING
   )?.[1] : void 0) ?? null;
   if (accentName === null && Object.keys(colors).length === 0) return null;
   return { colors, accentName };
 }
-var import_node_fs17, import_node_path18, ACCENT_BUILD_SETTING, PLIST_ACCENT;
+var import_node_fs19, import_node_path20, ACCENT_BUILD_SETTING, PLIST_ACCENT;
 var init_app_catalog = __esm({
   "cli/app-catalog.ts"() {
     "use strict";
-    import_node_fs17 = __toESM(require("node:fs"), 1);
-    import_node_path18 = __toESM(require("node:path"), 1);
+    import_node_fs19 = __toESM(require("node:fs"), 1);
+    import_node_path20 = __toESM(require("node:path"), 1);
     init_bundleAssets();
     ACCENT_BUILD_SETTING = /ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = "?([^";]+)"?;/;
     PLIST_ACCENT = /<key>NSAccentColorName<\/key>\s*<string>([^<]+)<\/string>/;
@@ -32366,9 +32580,9 @@ var init_app_catalog = __esm({
 // cli/app-project.ts
 function firstNamedFile(dir, names) {
   for (const name2 of names) {
-    const candidate = import_node_path19.default.join(dir, name2);
+    const candidate = import_node_path21.default.join(dir, name2);
     try {
-      if (import_node_fs18.default.statSync(candidate).isFile()) return candidate;
+      if (import_node_fs20.default.statSync(candidate).isFile()) return candidate;
     } catch {
     }
   }
@@ -32381,24 +32595,24 @@ function findRNXAppConfig(dir) {
   return firstNamedFile(dir, RNX_APP_CONFIG_NAMES);
 }
 function resolveAppProject(projectRoot) {
-  const appDir = import_node_path19.default.resolve(projectRoot);
+  const appDir = import_node_path21.default.resolve(projectRoot);
   try {
-    if (!import_node_fs18.default.statSync(appDir).isDirectory()) return null;
+    if (!import_node_fs20.default.statSync(appDir).isDirectory()) return null;
   } catch {
     return null;
   }
   const configPath = findRNXAppConfig(appDir);
-  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs18.default.existsSync(import_node_path19.default.join(appDir, "package.json"))) {
+  if (!configPath && !findExpoAppConfig(appDir) && !import_node_fs20.default.existsSync(import_node_path21.default.join(appDir, "package.json"))) {
     return null;
   }
   return { appDir, configPath };
 }
-var import_node_fs18, import_node_path19, EXPO_APP_CONFIG_NAMES, RNX_APP_CONFIG_NAMES;
+var import_node_fs20, import_node_path21, EXPO_APP_CONFIG_NAMES, RNX_APP_CONFIG_NAMES;
 var init_app_project = __esm({
   "cli/app-project.ts"() {
     "use strict";
-    import_node_fs18 = __toESM(require("node:fs"), 1);
-    import_node_path19 = __toESM(require("node:path"), 1);
+    import_node_fs20 = __toESM(require("node:fs"), 1);
+    import_node_path21 = __toESM(require("node:path"), 1);
     EXPO_APP_CONFIG_NAMES = [
       "app.config.js",
       "app.config.ts",
@@ -32427,13 +32641,13 @@ function isRNXConfig(value) {
 }
 function resolveConfigReplacementFiles(config, configPath) {
   if (!config.modules) return config;
-  const configDir = import_node_path20.default.dirname(configPath);
+  const configDir = import_node_path22.default.dirname(configPath);
   return {
     ...config,
     modules: Object.fromEntries(
       Object.entries(config.modules).map(([name2, resolution]) => [
         name2,
-        resolution && typeof resolution === "object" && "file" in resolution ? { ...resolution, file: import_node_path20.default.resolve(configDir, resolution.file) } : resolution
+        resolution && typeof resolution === "object" && "file" in resolution ? { ...resolution, file: import_node_path22.default.resolve(configDir, resolution.file) } : resolution
       ])
     )
   };
@@ -32463,17 +32677,17 @@ async function resolveRNXAppConfig(startDir = process.cwd()) {
   const project = resolveAppProject(startDir);
   return { project, config: await loadRNXAppConfig(project) };
 }
-var import_node_module, import_node_path20, import_jiti, require2;
+var import_node_module2, import_node_path22, import_jiti, require2;
 var init_app_config = __esm({
   "cli/app-config.ts"() {
     "use strict";
-    import_node_module = require("node:module");
-    import_node_path20 = __toESM(require("node:path"), 1);
+    import_node_module2 = require("node:module");
+    import_node_path22 = __toESM(require("node:path"), 1);
     init_src();
     import_jiti = require("jiti");
     init_public_brand();
     init_app_project();
-    require2 = (0, import_node_module.createRequire)(__sootsim_import_meta_url);
+    require2 = (0, import_node_module2.createRequire)(__sootsim_import_meta_url);
   }
 });
 
@@ -32525,13 +32739,13 @@ function discoverNativeLinkedAppFonts(opts) {
       scannedFontDirectories++;
       let entries;
       try {
-        entries = import_node_fs19.default.readdirSync(current.dir, { withFileTypes: true });
+        entries = import_node_fs21.default.readdirSync(current.dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const entry of entries) {
         if (entry.isSymbolicLink()) continue;
-        const fullPath = import_node_path21.default.join(current.dir, entry.name);
+        const fullPath = import_node_path23.default.join(current.dir, entry.name);
         if (entry.isDirectory()) {
           if (current.depth < 4 && pending.length < 64 && !entry.name.startsWith(".")) {
             pending.push({ dir: fullPath, depth: current.depth + 1 });
@@ -32539,15 +32753,15 @@ function discoverNativeLinkedAppFonts(opts) {
           continue;
         }
         if (!entry.isFile() || !/\.(ttf|otf|woff|woff2)$/i.test(entry.name)) continue;
-        const relative2 = import_node_path21.default.relative(root, fullPath).split(import_node_path21.default.sep).join("/");
-        fontPaths.push(import_node_path21.default.posix.join(metroPathPrefix, relative2));
+        const relative2 = import_node_path23.default.relative(root, fullPath).split(import_node_path23.default.sep).join("/");
+        fontPaths.push(import_node_path23.default.posix.join(metroPathPrefix, relative2));
         if (fontPaths.length >= 256) break;
       }
     }
   };
   try {
     const packageJson = JSON.parse(
-      import_node_fs19.default.readFileSync(import_node_path21.default.join(selectedAppDir, "package.json"), "utf8")
+      import_node_fs21.default.readFileSync(import_node_path23.default.join(selectedAppDir, "package.json"), "utf8")
     );
     const dependencyNames = /* @__PURE__ */ new Set();
     for (const field of ["dependencies", "devDependencies", "optionalDependencies"]) {
@@ -32562,24 +32776,24 @@ function discoverNativeLinkedAppFonts(opts) {
       const config = Reflect.get(packageJson, "reactNativeVectorIcons");
       const configuredFontDir = config && typeof config === "object" ? Reflect.get(config, "fontDir") : null;
       const configuredDir = typeof configuredFontDir === "string" ? configuredFontDir : "rnvi-fonts";
-      const root = import_node_path21.default.resolve(selectedAppDir, configuredDir);
-      const relativeRoot = import_node_path21.default.relative(selectedAppDir, root);
-      if (!relativeRoot.startsWith("..") && !import_node_path21.default.isAbsolute(relativeRoot)) {
-        collectFontFiles(root, relativeRoot.split(import_node_path21.default.sep).join("/"));
+      const root = import_node_path23.default.resolve(selectedAppDir, configuredDir);
+      const relativeRoot = import_node_path23.default.relative(selectedAppDir, root);
+      if (!relativeRoot.startsWith("..") && !import_node_path23.default.isAbsolute(relativeRoot)) {
+        collectFontFiles(root, relativeRoot.split(import_node_path23.default.sep).join("/"));
       }
-      const vectorIconRequire = (0, import_node_module2.createRequire)(import_node_path21.default.join(selectedAppDir, "package.json"));
+      const vectorIconRequire = (0, import_node_module3.createRequire)(import_node_path23.default.join(selectedAppDir, "package.json"));
       for (const dependencyName of vectorIconDependencies) {
         try {
           const entryPath = vectorIconRequire.resolve(dependencyName);
-          const dependencyPath = dependencyName.split("/").join(import_node_path21.default.sep);
-          const marker = `${import_node_path21.default.sep}node_modules${import_node_path21.default.sep}${dependencyPath}${import_node_path21.default.sep}`;
+          const dependencyPath = dependencyName.split("/").join(import_node_path23.default.sep);
+          const marker = `${import_node_path23.default.sep}node_modules${import_node_path23.default.sep}${dependencyPath}${import_node_path23.default.sep}`;
           const markerIndex = entryPath.lastIndexOf(marker);
           if (markerIndex === -1) continue;
           const packageRoot = entryPath.slice(0, markerIndex + marker.length - 1);
           const fontsDir = dependencyName === "react-native-vector-icons" ? "Fonts" : "fonts";
           collectFontFiles(
-            import_node_path21.default.join(packageRoot, fontsDir),
-            import_node_path21.default.posix.join("node_modules", dependencyName, fontsDir)
+            import_node_path23.default.join(packageRoot, fontsDir),
+            import_node_path23.default.posix.join("node_modules", dependencyName, fontsDir)
           );
         } catch {
         }
@@ -32588,37 +32802,37 @@ function discoverNativeLinkedAppFonts(opts) {
   } catch {
   }
   try {
-    const configPath = import_node_path21.default.join(selectedAppDir, "react-native.config.js");
-    if (import_node_fs19.default.statSync(configPath).isFile()) {
-      const appConfigRequire = (0, import_node_module2.createRequire)(import_node_path21.default.join(selectedAppDir, "package.json"));
+    const configPath = import_node_path23.default.join(selectedAppDir, "react-native.config.js");
+    if (import_node_fs21.default.statSync(configPath).isFile()) {
+      const appConfigRequire = (0, import_node_module3.createRequire)(import_node_path23.default.join(selectedAppDir, "package.json"));
       const rnConfig = appConfigRequire(configPath);
       const assets = rnConfig && typeof rnConfig === "object" ? Reflect.get(rnConfig, "assets") : null;
       if (Array.isArray(assets)) {
         for (const assetDir of assets) {
           if (typeof assetDir !== "string") continue;
-          const root = import_node_path21.default.resolve(selectedAppDir, assetDir);
-          const relativeRoot = import_node_path21.default.relative(selectedAppDir, root);
-          if (relativeRoot.startsWith("..") || import_node_path21.default.isAbsolute(relativeRoot)) continue;
-          collectFontFiles(root, relativeRoot.split(import_node_path21.default.sep).join("/"));
+          const root = import_node_path23.default.resolve(selectedAppDir, assetDir);
+          const relativeRoot = import_node_path23.default.relative(selectedAppDir, root);
+          if (relativeRoot.startsWith("..") || import_node_path23.default.isAbsolute(relativeRoot)) continue;
+          collectFontFiles(root, relativeRoot.split(import_node_path23.default.sep).join("/"));
         }
       }
     }
   } catch {
   }
   if (platform === "ios") {
-    const iosDir = import_node_path21.default.join(selectedAppDir, "ios");
+    const iosDir = import_node_path23.default.join(selectedAppDir, "ios");
     try {
-      const targetDirs = import_node_fs19.default.readdirSync(iosDir, { withFileTypes: true }).filter(
+      const targetDirs = import_node_fs21.default.readdirSync(iosDir, { withFileTypes: true }).filter(
         (entry) => entry.isDirectory() && !entry.isSymbolicLink() && entry.name !== "Pods" && entry.name !== "build" && !entry.name.startsWith(".")
       ).slice(0, 64);
-      const plistPaths = [import_node_path21.default.join(iosDir, "Info.plist")];
+      const plistPaths = [import_node_path23.default.join(iosDir, "Info.plist")];
       for (const entry of targetDirs) {
-        plistPaths.push(import_node_path21.default.join(iosDir, entry.name, "Info.plist"));
+        plistPaths.push(import_node_path23.default.join(iosDir, entry.name, "Info.plist"));
       }
       for (const plistPath of plistPaths) {
         let parsed;
         try {
-          parsed = parsePlistSource(import_node_fs19.default.readFileSync(plistPath, "utf8"));
+          parsed = parsePlistSource(import_node_fs21.default.readFileSync(plistPath, "utf8"));
         } catch {
           continue;
         }
@@ -32628,21 +32842,21 @@ function discoverNativeLinkedAppFonts(opts) {
         for (const declaredFont of declaredFonts) {
           if (typeof declaredFont !== "string") continue;
           const candidates = [
-            import_node_path21.default.resolve(import_node_path21.default.dirname(plistPath), declaredFont),
-            import_node_path21.default.resolve(iosDir, declaredFont)
+            import_node_path23.default.resolve(import_node_path23.default.dirname(plistPath), declaredFont),
+            import_node_path23.default.resolve(iosDir, declaredFont)
           ];
           const fontPath = candidates.find((candidate) => {
-            const relative2 = import_node_path21.default.relative(selectedAppDir, candidate);
-            if (relative2.startsWith("..") || import_node_path21.default.isAbsolute(relative2)) return false;
+            const relative2 = import_node_path23.default.relative(selectedAppDir, candidate);
+            if (relative2.startsWith("..") || import_node_path23.default.isAbsolute(relative2)) return false;
             try {
-              return import_node_fs19.default.statSync(candidate).isFile();
+              return import_node_fs21.default.statSync(candidate).isFile();
             } catch {
               return false;
             }
           });
           if (!fontPath) continue;
           fontPaths.push(
-            import_node_path21.default.relative(selectedAppDir, fontPath).split(import_node_path21.default.sep).join("/")
+            import_node_path23.default.relative(selectedAppDir, fontPath).split(import_node_path23.default.sep).join("/")
           );
         }
       }
@@ -32681,19 +32895,19 @@ async function resolveMetroProjectRoot(bundleUrl, opts) {
 function encodeAppFontsWire(specs) {
   return specs.map((spec) => `${encodeURIComponent(spec.url)}::${encodeURIComponent(spec.family)}`).join(",");
 }
-var import_node_fs19, import_node_module2, import_node_path21, import_config_plugin_fonts, require3;
+var import_node_fs21, import_node_module3, import_node_path23, import_config_plugin_fonts, require3;
 var init_app_fonts = __esm({
   "cli/app-fonts.ts"() {
     "use strict";
-    import_node_fs19 = __toESM(require("node:fs"), 1);
-    import_node_module2 = require("node:module");
-    import_node_path21 = __toESM(require("node:path"), 1);
+    import_node_fs21 = __toESM(require("node:fs"), 1);
+    import_node_module3 = require("node:module");
+    import_node_path23 = __toESM(require("node:path"), 1);
     import_config_plugin_fonts = require("peach-engine/engine/config-plugin-fonts");
     init_dev_server_scanner();
     init_backend_origin();
     init_plist();
     init_app_project();
-    require3 = (0, import_node_module2.createRequire)(__sootsim_import_meta_url);
+    require3 = (0, import_node_module3.createRequire)(__sootsim_import_meta_url);
   }
 });
 
@@ -32762,15 +32976,15 @@ function splashImageUrls(spec) {
   if (spec.dark?.backgroundImageUrl) urls.add(spec.dark.backgroundImageUrl);
   return [...urls];
 }
-var import_node_module3, import_config_plugin_splash, require4;
+var import_node_module4, import_config_plugin_splash, require4;
 var init_app_splash = __esm({
   "cli/app-splash.ts"() {
     "use strict";
-    import_node_module3 = require("node:module");
+    import_node_module4 = require("node:module");
     import_config_plugin_splash = require("peach-engine/engine/config-plugin-splash");
     init_backend_origin();
     init_app_project();
-    require4 = (0, import_node_module3.createRequire)(__sootsim_import_meta_url);
+    require4 = (0, import_node_module4.createRequire)(__sootsim_import_meta_url);
   }
 });
 
@@ -33866,15 +34080,16 @@ var init_internal_child = __esm({
 // cli/drivers/playwright-provisioning.ts
 function resolvePlaywright() {
   const roots = [`${process.cwd()}/`];
-  if (process.argv[1]) roots.push(process.argv[1]);
+  const self = rnxSelfInvocation();
+  roots.push(self.prefixArgs[0] ?? self.executable);
   for (const root of roots) {
     try {
-      const requireFromRoot = (0, import_node_module4.createRequire)(root);
+      const requireFromRoot = (0, import_node_module5.createRequire)(root);
       for (const spec of ["playwright", "playwright-chromium", "playwright-core"]) {
         try {
           const modulePath = requireFromRoot.resolve(spec);
           const packageJsonPath = requireFromRoot.resolve(`${spec}/package.json`);
-          const parsed = JSON.parse((0, import_node_fs20.readFileSync)(packageJsonPath, "utf8"));
+          const parsed = JSON.parse((0, import_node_fs22.readFileSync)(packageJsonPath, "utf8"));
           if (!isRecord(parsed) || typeof parsed.version !== "string") continue;
           const bin = parsed.bin;
           let binPath = null;
@@ -33886,8 +34101,8 @@ function resolvePlaywright() {
             binPath = typeof named === "string" ? named : typeof first === "string" ? first : null;
           }
           if (!binPath) continue;
-          const cliPath = (0, import_node_path22.join)((0, import_node_path22.dirname)(packageJsonPath), binPath);
-          if (!(0, import_node_fs20.existsSync)(cliPath)) continue;
+          const cliPath = (0, import_node_path24.join)((0, import_node_path24.dirname)(packageJsonPath), binPath);
+          if (!(0, import_node_fs22.existsSync)(cliPath)) continue;
           return {
             spec,
             modulePath,
@@ -33931,7 +34146,7 @@ function probeBrowser(resolved, env) {
     return {
       ok: true,
       executablePath: parsed.executablePath,
-      exists: parsed.exists && (0, import_node_fs20.existsSync)(parsed.executablePath)
+      exists: parsed.exists && (0, import_node_fs22.existsSync)(parsed.executablePath)
     };
   } catch (error) {
     return {
@@ -33982,17 +34197,17 @@ ${detail}` : ""}`
   }
   return { ok: true, executablePath: after.executablePath, installed: true };
 }
-var import_node_child_process6, import_node_fs20, import_node_module4, import_node_path22;
+var import_node_child_process6, import_node_fs22, import_node_module5, import_node_path24;
 var init_playwright_provisioning = __esm({
   "cli/drivers/playwright-provisioning.ts"() {
     "use strict";
     import_node_child_process6 = require("node:child_process");
-    import_node_fs20 = require("node:fs");
-    import_node_module4 = require("node:module");
-    import_node_path22 = require("node:path");
+    import_node_fs22 = require("node:fs");
+    import_node_module5 = require("node:module");
+    import_node_path24 = require("node:path");
+    init_is_record();
     init_internal_child();
     init_self_invocation();
-    init_is_record();
   }
 });
 
@@ -34658,7 +34873,7 @@ function assertExplicitBridgeLock(preferredPort, explicitPort, lock) {
 async function ensureRuntimeForOpen() {
   if (resolveDevCheckoutRuntimeRoot()) return;
   const active = readActiveRuntime();
-  if (active && import_node_fs21.default.existsSync(runtimeDir(active))) return;
+  if (active && import_node_fs23.default.existsSync(runtimeDir(active))) return;
   console.error("  installing peach engine runtime...");
   const { runRuntime: runRuntime2 } = await Promise.resolve().then(() => (init_runtime(), runtime_exports));
   await runRuntime2(["install"], {});
@@ -34812,10 +35027,10 @@ async function buildResolvedBundleOpenUrl(target, baseUrl, opts = {}) {
 }
 function normalizeReplacementPath(filePath) {
   if (filePath.startsWith("~/")) {
-    return import_node_path23.default.join(import_node_os3.default.homedir(), filePath.slice(2));
+    return import_node_path25.default.join(import_node_os3.default.homedir(), filePath.slice(2));
   }
-  if (import_node_path23.default.isAbsolute(filePath)) return filePath;
-  return import_node_path23.default.resolve(process.cwd(), filePath);
+  if (import_node_path25.default.isAbsolute(filePath)) return filePath;
+  return import_node_path25.default.resolve(process.cwd(), filePath);
 }
 function parseOpenRuntimeConfig(args) {
   const modules = {};
@@ -34834,7 +35049,7 @@ function parseOpenRuntimeConfig(args) {
       }
       const moduleName = raw.slice(0, eqIndex).trim();
       const filePath = normalizeReplacementPath(raw.slice(eqIndex + 1).trim());
-      if (!import_node_fs21.default.existsSync(filePath)) {
+      if (!import_node_fs23.default.existsSync(filePath)) {
         console.error(`  peach open: replacement file not found: ${filePath}`);
         rnxExit(1);
       }
@@ -34865,7 +35080,7 @@ async function resolveAppProjectForBundleUrl(bundleUrl) {
   return advertisedRoot ? resolveAppProject(advertisedRoot) : null;
 }
 async function ensureConfiguredRuntime(version) {
-  if (import_node_fs21.default.existsSync(import_node_path23.default.join(runtimeDir(version), "index.html"))) return;
+  if (import_node_fs23.default.existsSync(import_node_path25.default.join(runtimeDir(version), "index.html"))) return;
   console.error(`  installing configured engine runtime ${version}...`);
   const result = await rnxRuntime.install({
     version,
@@ -34983,6 +35198,22 @@ async function stampAppSplash(urlStr, project) {
     return urlStr;
   }
 }
+function stampNativeFirebaseConfig(urlStr, project) {
+  const url = new URL(urlStr);
+  if (!url.searchParams.get("bundle") || !project) return urlStr;
+  try {
+    url.searchParams.set(
+      "nativeFirebase",
+      JSON.stringify(readNativeFirebaseConfig(project.appDir))
+    );
+  } catch (error) {
+    url.searchParams.set(
+      "nativeFirebase",
+      JSON.stringify({ error: error instanceof Error ? error.message : String(error) })
+    );
+  }
+  return url.toString();
+}
 function stampAppCatalog(urlStr, project) {
   try {
     const url = new URL(urlStr);
@@ -35017,8 +35248,11 @@ function bundleUrlOf(urlStr) {
 async function buildShellUrl(target, baseUrl = resolveDefaultShellBaseUrl(), opts = {}) {
   const resolved = await resolveShellUrl(target, baseUrl, opts);
   const project = opts.project ?? await resolveAppProjectForBundleUrl(bundleUrlOf(resolved));
-  const stamped = stampAppCatalog(
-    await stampAppSplash(await stampAppFonts(resolved, project), project),
+  const stamped = stampNativeFirebaseConfig(
+    stampAppCatalog(
+      await stampAppSplash(await stampAppFonts(resolved, project), project),
+      project
+    ),
     project
   );
   if (!opts.device && !opts.proof && !opts.posture && !opts.osVersion && !opts.env?.length)
@@ -35044,6 +35278,7 @@ function deriveCurrentSimBaseUrl(sim, fallback) {
     url.searchParams.delete("appFonts");
     url.searchParams.delete("appSplash");
     url.searchParams.delete("appCatalog");
+    url.searchParams.delete("nativeFirebase");
     return url.toString();
   } catch {
     return fallback;
@@ -35159,7 +35394,7 @@ function playwrightHostPidForSim(sim) {
 function signalDriverLaunchConnected(result) {
   if (!result.connectAckFile) return false;
   try {
-    import_node_fs21.default.writeFileSync(
+    import_node_fs23.default.writeFileSync(
       result.connectAckFile,
       `${JSON.stringify({ connectedAt: Date.now(), pid: result.pid ?? null })}
 `,
@@ -35173,19 +35408,19 @@ function signalDriverLaunchConnected(result) {
 function printDriverDiagnosticLogTail(result) {
   if (!result.diagnosticLogPath) return;
   try {
-    const detail = import_node_fs21.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
+    const detail = import_node_fs23.default.readFileSync(result.diagnosticLogPath, "utf8").trim();
     if (!detail) {
-      console.error(`  ${import_node_path23.default.basename(result.diagnosticLogPath)} was empty`);
+      console.error(`  ${import_node_path25.default.basename(result.diagnosticLogPath)} was empty`);
       return;
     }
     const shown = detail.length > 4e3 ? `\u2026
 ${detail.slice(-4e3)}` : detail;
-    console.error(`  ${import_node_path23.default.basename(result.diagnosticLogPath)}:`);
+    console.error(`  ${import_node_path25.default.basename(result.diagnosticLogPath)}:`);
     console.error(shown);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(
-      `  failed to read ${import_node_path23.default.basename(result.diagnosticLogPath)}: ${message}`
+      `  failed to read ${import_node_path25.default.basename(result.diagnosticLogPath)}: ${message}`
     );
   }
 }
@@ -35558,9 +35793,9 @@ async function runOpenCommand(args, opts = {}) {
   }
   const hotMode = hotFlag ? true : noHmrFlag ? false : driverId !== "playwright";
   const deviceArg = args.find((_, i) => args[i - 1] === "--device");
-  if (deviceArg && !(deviceArg in import_settings.devices)) {
+  if (deviceArg && !(deviceArg in import_devices2.devices)) {
     console.error(`  peach open: unknown device "${deviceArg}"`);
-    console.error(`  known devices: ${(0, import_settings.listSelectableDeviceModels)().join(", ")}`);
+    console.error(`  known devices: ${(0, import_devices2.listSelectableDeviceModels)().join(", ")}`);
     rnxExit(1);
   }
   const postureArg = args.find((_, i) => args[i - 1] === "--posture");
@@ -35568,7 +35803,7 @@ async function runOpenCommand(args, opts = {}) {
     console.error(`  peach open: --posture must be open or closed, got "${postureArg}"`);
     rnxExit(1);
   }
-  const deviceFitBox = deviceArg ? (0, import_settings.resolveDeviceFitBox)(
+  const deviceFitBox = deviceArg ? (0, import_devices2.resolveDeviceFitBox)(
     deviceArg,
     false,
     void 0,
@@ -36115,16 +36350,16 @@ async function runCloseCommand(args, opts = {}) {
     bridge.close();
   }
 }
-var import_node_child_process7, import_node_fs21, import_node_os3, import_node_path23, import_app_catalog_wire, import_settings, import_ws4, DEFAULT_DRIVER_CONNECT_TIMEOUT_MS, DRIVER_CONNECT_INTERVAL_MS, DRIVER_CONNECT_HOST_GRACE_MS, OPEN_BRIDGE_SPAWN_TIMEOUT_MS, SHELL_APPS, DEV_BUNDLE_RESOLVE_ATTEMPTS, DEV_BUNDLE_RESOLVE_INTERVAL_MS;
+var import_node_child_process7, import_node_fs23, import_node_os3, import_node_path25, import_app_catalog_wire, import_devices2, import_ws4, DEFAULT_DRIVER_CONNECT_TIMEOUT_MS, DRIVER_CONNECT_INTERVAL_MS, DRIVER_CONNECT_HOST_GRACE_MS, OPEN_BRIDGE_SPAWN_TIMEOUT_MS, SHELL_APPS, DEV_BUNDLE_RESOLVE_ATTEMPTS, DEV_BUNDLE_RESOLVE_INTERVAL_MS;
 var init_control = __esm({
   "cli/commands/control.ts"() {
     "use strict";
     import_node_child_process7 = require("node:child_process");
-    import_node_fs21 = __toESM(require("node:fs"), 1);
+    import_node_fs23 = __toESM(require("node:fs"), 1);
     import_node_os3 = __toESM(require("node:os"), 1);
-    import_node_path23 = __toESM(require("node:path"), 1);
+    import_node_path25 = __toESM(require("node:path"), 1);
     import_app_catalog_wire = require("peach-engine/engine/app-catalog-wire");
-    import_settings = require("peach-engine/settings");
+    import_devices2 = require("peach-engine/settings/devices");
     import_ws4 = require("ws");
     init_dev_server_scanner();
     init_app_url();
@@ -36135,6 +36370,7 @@ var init_control = __esm({
     init_flow_timeout_scale();
     init_home_paths();
     init_native_dev_bundle_url();
+    init_native_firebase_config();
     init_profiles();
     init_public_brand();
     init_runtime_assets();
@@ -36264,13 +36500,13 @@ var require_proof_frame = __commonJS({
 
 // src/screenshots/frame-compose.ts
 function getFramedScreenshotLayout(model) {
-  const spec = (0, import_settings2.getDevice)(model);
+  const spec = (0, import_devices3.getDevice)(model);
   const renderScale = spec.scale;
   const isLegacyHardware = spec.statusBarHeight > 0 && !spec.dynamicIsland && spec.homeIndicatorHeight === 0 && // home-button iphones have a square display, so any corner reads 0
   spec.cornerRadius.topLeft === 0;
   const logicalScreenWidth = spec.width;
   const logicalScreenHeight = spec.height;
-  const modernGeometry = (0, import_settings2.resolveDeviceFrameGeometry)(spec);
+  const modernGeometry = (0, import_devices3.resolveDeviceFrameGeometry)(spec);
   const housingLayers = isLegacyHardware ? null : (0, import_duo_housing.resolveHousingArt)(spec.posture ?? "closed", modernGeometry, {
     orientation: spec.orientation,
     landscapeSide: spec.landscapeSide
@@ -36283,7 +36519,7 @@ function getFramedScreenshotLayout(model) {
   const logicalOuterHeight = logicalFrameHeight + FRAME_OUTLINE_BLEED * 2;
   const logicalScreenLeft = logicalFrameLeft + (isLegacyHardware ? import_chrome_metrics.LEGACY_SIDE_BEZEL : modernGeometry.screenLeft);
   const logicalScreenTop = isLegacyHardware ? import_chrome_metrics.LEGACY_TOP_BEZEL : modernGeometry.screenTop;
-  const logicalFrameRadius = isLegacyHardware ? (0, import_settings2.cornerRadii)(import_chrome_metrics.LEGACY_FRAME_RADIUS) : modernGeometry.frameRadius;
+  const logicalFrameRadius = isLegacyHardware ? (0, import_devices3.cornerRadii)(import_chrome_metrics.LEGACY_FRAME_RADIUS) : modernGeometry.frameRadius;
   const buttons = [
     {
       side: spec.hardwareButtons.lock.side,
@@ -36325,7 +36561,7 @@ function getFramedScreenshotLayout(model) {
     logicalScreenHeight,
     logicalScreenLeft,
     logicalScreenTop,
-    logicalScreenRadius: isLegacyHardware ? (0, import_settings2.cornerRadii)(0) : modernGeometry.screenRadius,
+    logicalScreenRadius: isLegacyHardware ? (0, import_devices3.cornerRadii)(0) : modernGeometry.screenRadius,
     logicalFrameRadius,
     housingLayers,
     // the housing paints its own body layer, shadow included: its frame box is
@@ -36383,7 +36619,7 @@ function renderFrameHtml(layout, rawImageDataUrl) {
         style="
           position:absolute;
           inset:0;
-          border-radius:${(0, import_settings2.formatCornerRadii)(layout.logicalFrameRadius)};
+          border-radius:${(0, import_devices3.formatCornerRadii)(layout.logicalFrameRadius)};
           box-shadow:${layout.metallicRingShadow};
           pointer-events:none;
           z-index:10;
@@ -36504,7 +36740,7 @@ function renderFrameHtml(layout, rawImageDataUrl) {
           left:${layout.logicalFrameLeft}px;
           width:${layout.logicalFrameWidth}px;
           height:${layout.logicalFrameHeight}px;
-            border-radius:${layout.housingLayers ? "0" : (0, import_settings2.formatCornerRadii)(layout.logicalFrameRadius)};
+            border-radius:${layout.housingLayers ? "0" : (0, import_devices3.formatCornerRadii)(layout.logicalFrameRadius)};
             box-sizing:border-box;
             overflow:visible;
             background:${layout.frameBackground};
@@ -36523,7 +36759,7 @@ function renderFrameHtml(layout, rawImageDataUrl) {
               left:${layout.logicalScreenLeft - layout.logicalFrameLeft}px;
               width:${layout.logicalScreenWidth}px;
               height:${layout.logicalScreenHeight}px;
-              border-radius:${(0, import_settings2.formatCornerRadii)(layout.logicalScreenRadius)};
+              border-radius:${(0, import_devices3.formatCornerRadii)(layout.logicalScreenRadius)};
               overflow:hidden;
               background:#000;
             "
@@ -36595,13 +36831,13 @@ async function createFramedScreenshotComposer(browser) {
     }
   };
 }
-var import_chrome_metrics, import_duo_housing, import_settings2, METALLIC_RING_SHADOW, FRAME_OUTLINE_BLEED;
+var import_chrome_metrics, import_duo_housing, import_devices3, METALLIC_RING_SHADOW, FRAME_OUTLINE_BLEED;
 var init_frame_compose = __esm({
   "src/screenshots/frame-compose.ts"() {
     "use strict";
     import_chrome_metrics = require("peach-engine/ios/chrome-metrics");
     import_duo_housing = require("peach-engine/ios/duo-housing");
-    import_settings2 = require("peach-engine/settings");
+    import_devices3 = require("peach-engine/settings/devices");
     init_reap_browser();
     METALLIC_RING_SHADOW = "inset 0 0 0 0.5px #000, inset 0 0 0 2px #757575, inset 0 0 0 5px #212121";
     FRAME_OUTLINE_BLEED = 1;
@@ -37245,16 +37481,16 @@ function readRecentShellAppId(state) {
 }
 function resolveProjectRelativeFlowBase(flowDir) {
   if (!flowDir) return process.cwd();
-  return path19.basename(flowDir) === ".maestro" ? path19.dirname(flowDir) : flowDir;
+  return path20.basename(flowDir) === ".maestro" ? path20.dirname(flowDir) : flowDir;
 }
 function resolveFlowScreenshotPathWithMode(screenshotDir, name2, opts) {
   const normalizedName = name2.endsWith(".png") ? name2 : `${name2}.png`;
-  if (path19.isAbsolute(normalizedName)) return normalizedName;
+  if (path20.isAbsolute(normalizedName)) return normalizedName;
   if (opts.mode === "flow" && /[\\/]/.test(normalizedName)) {
     const baseDir = normalizedName.startsWith("./") || normalizedName.startsWith("../") ? opts.flowDir ?? process.cwd() : resolveProjectRelativeFlowBase(opts.flowDir);
-    return path19.resolve(baseDir, normalizedName);
+    return path20.resolve(baseDir, normalizedName);
   }
-  return path19.join(screenshotDir, normalizedName);
+  return path20.join(screenshotDir, normalizedName);
 }
 function normalizeFlowScreenshotSpec(step) {
   if (typeof step === "string") {
@@ -37311,13 +37547,13 @@ function parseFlowSteps(content) {
   const parsed = import_yaml.default.parse(candidate);
   return Array.isArray(parsed) ? parsed : [];
 }
-var fs19, path19, import_settings3, import_yaml, import_proof_frame, DEFAULT_TIMEOUT, ASSERTION_LOOKUP_MS, FLOW_TIMEOUT_SCALE, scaledTimeout, MAESTRO_SELECTOR_KEYS, SELECTOR_FILTER_KEYS, UNSUPPORTED_SELECTOR_KEYS, MAESTRO_PERMISSION_KINDS, MAESTRO_PERMISSION_STATUS, SootSimBridgeFlowRunner;
+var fs20, path20, import_devices4, import_yaml, import_proof_frame, DEFAULT_TIMEOUT, ASSERTION_LOOKUP_MS, FLOW_TIMEOUT_SCALE, scaledTimeout, MAESTRO_SELECTOR_KEYS, SELECTOR_FILTER_KEYS, UNSUPPORTED_SELECTOR_KEYS, MAESTRO_PERMISSION_KINDS, MAESTRO_PERMISSION_STATUS, SootSimBridgeFlowRunner;
 var init_bridge_flow_runner = __esm({
   "cli/bridge-flow-runner.ts"() {
     "use strict";
-    fs19 = __toESM(require("fs"), 1);
-    path19 = __toESM(require("path"), 1);
-    import_settings3 = require("peach-engine/settings");
+    fs20 = __toESM(require("fs"), 1);
+    path20 = __toESM(require("path"), 1);
+    import_devices4 = require("peach-engine/settings/devices");
     import_yaml = __toESM(require("yaml"), 1);
     import_proof_frame = __toESM(require_proof_frame(), 1);
     init_flow_timeout_scale();
@@ -37633,14 +37869,14 @@ var init_bridge_flow_runner = __esm({
         if (chunks.length === 0) {
           throw new Error("recording requested but no video buffer was produced");
         }
-        fs19.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
+        fs20.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
         const videoMime = stopped.mime || this.opts.recordingFormat || "video/webm";
         const extension = videoMime.includes("mp4") ? "mp4" : "webm";
-        const outputPath = path19.join(
+        const outputPath = path20.join(
           this.opts.recordingOutputDir,
           `peach-${Date.now()}.${extension}`
         );
-        fs19.writeFileSync(outputPath, Buffer.concat(chunks));
+        fs20.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
       }
       async waitForRecordingTail(opts) {
@@ -38000,6 +38236,7 @@ var init_bridge_flow_runner = __esm({
       }
       async tapOn(target) {
         const opts = typeof target === "string" ? { text: target } : target;
+        await this.waitForAppToSettle();
         const repeat = Math.max(1, Math.trunc(opts.repeat ?? 1));
         const repeatDelay = opts.delay !== void 0 && opts.delay >= 0 ? opts.delay : 100;
         const repeatTaps = async (tappedAtMs, tapAgain) => {
@@ -38272,7 +38509,7 @@ var init_bridge_flow_runner = __esm({
             flowDir: this.opts.flowDir
           }
         );
-        fs19.mkdirSync(path19.dirname(outputPath), { recursive: true });
+        fs20.mkdirSync(path20.dirname(outputPath), { recursive: true });
         const layers = spec.layers ?? this.opts.screenshotLayers;
         const screenshotRequest = {
           type: "screenshot",
@@ -38307,11 +38544,11 @@ var init_bridge_flow_runner = __esm({
             throw new Error("could not read current device model for framed screenshot");
           }
           const framed = await composeFramedScreenshot(rawBuffer, model);
-          fs19.writeFileSync(outputPath, framed);
+          fs20.writeFileSync(outputPath, framed);
           console.log(`[flow] screenshot: ${outputPath} (frame: ${model})`);
           return outputPath;
         }
-        fs19.writeFileSync(outputPath, rawBuffer);
+        fs20.writeFileSync(outputPath, rawBuffer);
         console.log(`[flow] screenshot: ${outputPath}`);
         return outputPath;
       }
@@ -38323,7 +38560,7 @@ var init_bridge_flow_runner = __esm({
           args: []
         });
         const model = settings && typeof settings.deviceModel === "string" ? settings.deviceModel : null;
-        if (!model || !(model in import_settings3.devices)) return null;
+        if (!model || !(model in import_devices4.devices)) return null;
         return model;
       }
       async captureScreenshot(outputPath) {
@@ -38333,10 +38570,10 @@ var init_bridge_flow_runner = __esm({
       // + a11y tree + console errors/warnings + failed network requests +
       // shell state, all under one directory so post-mortem is one grep away.
       async captureFailureBundle(outputDir, context) {
-        fs19.mkdirSync(outputDir, { recursive: true });
+        fs20.mkdirSync(outputDir, { recursive: true });
         const write = (name2, content) => {
           try {
-            fs19.writeFileSync(path19.join(outputDir, name2), content);
+            fs20.writeFileSync(path20.join(outputDir, name2), content);
           } catch {
           }
         };
@@ -38783,14 +39020,14 @@ var init_bridge_flow_runner = __esm({
           );
         }
       }
-      // maestro waits after every input for the screen to stop changing, up to
+      // maestro waits around taps for the screen to stop changing, up to
       // its ios driver's 3 s settle budget, comparing screenshots, so an action
       // still in flight (a submit spinner, a sheet closing) finishes before the
       // next command resolves its target. an app can take a few hundred ms to
       // react to a press, so stillness must hold about half a second, and it
       // counts painted frames because a spinner repaints without moving layout.
       // a screen that never stops proceeds when the budget runs out, as there.
-      async settleAfterInput() {
+      async waitForAppToSettle() {
         await waitForSootsimIdle({
           bridge: this.bridge,
           simId: this.opts.simId,
@@ -38800,6 +39037,9 @@ var init_bridge_flow_runner = __esm({
           strict: true,
           paintStill: true
         });
+      }
+      async settleAfterInput() {
+        await this.waitForAppToSettle();
         this.lastInteractionAt = Date.now();
       }
       async waitForVisualSettle() {
@@ -38931,8 +39171,8 @@ var init_bridge_flow_runner = __esm({
       runScript(target) {
         const spec = typeof target === "string" ? { file: target } : target;
         if (!spec.file) throw new Error("runScript requires a file");
-        const scriptPath = path19.resolve(this.opts.flowDir, spec.file);
-        const source = fs19.readFileSync(scriptPath, "utf8");
+        const scriptPath = path20.resolve(this.opts.flowDir, spec.file);
+        const source = fs20.readFileSync(scriptPath, "utf8");
         this.js.evaluate(source, { env: spec.env });
         console.log(`[flow]   runScript: ${spec.file} done`);
       }
@@ -39289,10 +39529,10 @@ var init_bridge_flow_runner = __esm({
               for (const [k, v] of Object.entries(env)) this.js.putEnv(k, v);
             }
             if (file) {
-              const flowPath = path19.resolve(this.opts.flowDir, file);
-              const flowContent = fs19.readFileSync(flowPath, "utf8");
+              const flowPath = path20.resolve(this.opts.flowDir, file);
+              const flowContent = fs20.readFileSync(flowPath, "utf8");
               const previousDir = this.opts.flowDir;
-              this.opts.flowDir = path19.dirname(flowPath);
+              this.opts.flowDir = path20.dirname(flowPath);
               try {
                 await this.runFlow(parseFlowSteps(flowContent));
               } finally {
@@ -39463,8 +39703,8 @@ __export(registry_exports, {
   skillRegistry: () => skillRegistry
 });
 module.exports = __toCommonJS(registry_exports);
-var fs20 = __toESM(require("fs"), 1);
-var path20 = __toESM(require("path"), 1);
+var fs21 = __toESM(require("fs"), 1);
+var path21 = __toESM(require("path"), 1);
 
 // src/skills/builtin/a11y-review.ts
 init_reap_browser();
@@ -39483,8 +39723,8 @@ var skill = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path21 = await import("path");
-        const fs21 = await import("fs");
+        const path22 = await import("path");
+        const fs22 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -39539,9 +39779,9 @@ var skill = {
             warnings: issues.filter((i) => i.severity === "warning").length,
             tree: typeof tree === "string" ? tree : JSON.stringify(tree)
           };
-          const reportPath = path21.join(context.outputDir, "a11y-report.json");
-          fs21.mkdirSync(path21.dirname(reportPath), { recursive: true });
-          fs21.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path22.join(context.outputDir, "a11y-report.json");
+          fs22.mkdirSync(path22.dirname(reportPath), { recursive: true });
+          fs22.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: issues.filter((i) => i.severity === "error").length === 0,
             message: `${report.errors} errors, ${report.warnings} warnings across ${report.nodeCount} nodes`,
@@ -39574,14 +39814,14 @@ var skill2 = {
         }
       },
       async execute(params, context) {
-        const fs21 = await import("node:fs");
-        const path21 = await import("node:path");
+        const fs22 = await import("node:fs");
+        const path22 = await import("node:path");
         const { COMPAT_RESULT_CAVEAT: COMPAT_RESULT_CAVEAT2, formatPackageStatus: formatPackageStatus2, formatScanCounts: formatScanCounts2, scanDeps: scanDeps2 } = await Promise.resolve().then(() => (init_web(), web_exports));
-        const packagePath = path21.join(context.projectDir, "package.json");
-        if (!fs21.existsSync(packagePath)) {
+        const packagePath = path22.join(context.projectDir, "package.json");
+        if (!fs22.existsSync(packagePath)) {
           return { success: false, message: "No package.json found" };
         }
-        const parsed = JSON.parse(fs21.readFileSync(packagePath, "utf8"));
+        const parsed = JSON.parse(fs22.readFileSync(packagePath, "utf8"));
         if (!parsed || typeof parsed !== "object") {
           return { success: false, message: "package.json is not an object" };
         }
@@ -39593,9 +39833,9 @@ var skill2 = {
         }) : scanDeps2(parsed);
         const packageResult = params.packageName ? scan.packages[0] : void 0;
         const message = packageResult ? `${params.packageName}: ${formatPackageStatus2(packageResult)}. ${COMPAT_RESULT_CAVEAT2}` : `${formatScanCounts2(scan)}. ${COMPAT_RESULT_CAVEAT2}`;
-        const reportPath = path21.join(context.outputDir, "compat-report.json");
-        fs21.mkdirSync(path21.dirname(reportPath), { recursive: true });
-        fs21.writeFileSync(reportPath, `${JSON.stringify(scan, null, 2)}
+        const reportPath = path22.join(context.outputDir, "compat-report.json");
+        fs22.mkdirSync(path22.dirname(reportPath), { recursive: true });
+        fs22.writeFileSync(reportPath, `${JSON.stringify(scan, null, 2)}
 `);
         return {
           success: true,
@@ -39637,8 +39877,8 @@ var skill3 = {
         record: { type: "boolean", description: "Record video of the flow" }
       },
       async execute(params, context) {
-        const fs21 = await import("fs");
-        const path21 = await import("path");
+        const fs22 = await import("fs");
+        const path22 = await import("path");
         const yaml2 = await import("yaml");
         const { DEFAULT_SOOTSIM_BRIDGE_PORT: DEFAULT_SOOTSIM_BRIDGE_PORT3 } = await Promise.resolve().then(() => (init_bridge_constants(), bridge_constants_exports));
         const { SootSimBridgeHost: SootSimBridgeHost2 } = await Promise.resolve().then(() => (init_bridge_host(), bridge_host_exports));
@@ -39648,7 +39888,7 @@ var skill3 = {
         const host = new SootSimBridgeHost2({ port: DEFAULT_SOOTSIM_BRIDGE_PORT3 });
         host.start({ silent: true });
         try {
-          const flowContent = fs21.readFileSync(params.flowPath, "utf8");
+          const flowContent = fs22.readFileSync(params.flowPath, "utf8");
           const fmMatch = flowContent.match(/^---\n([\s\S]*?)\n---\n?/);
           const stepsBody = fmMatch ? flowContent.slice(fmMatch[0].length) : flowContent;
           const steps = yaml2.parse(stepsBody);
@@ -39675,7 +39915,7 @@ var skill3 = {
           });
           const driver = new SootSimBridgeFlowRunner2(bridge, {
             screenshotDir: context.outputDir,
-            flowDir: path21.dirname(path21.resolve(params.flowPath)),
+            flowDir: path22.dirname(path22.resolve(params.flowPath)),
             simId,
             recordingOutputDir: params.record ? context.outputDir : void 0
           });
@@ -39697,7 +39937,7 @@ var skill3 = {
                 simId,
                 videoPath: videoPath || void 0
               },
-              artifacts: videoPath ? [{ type: "video", name: path21.basename(videoPath), path: videoPath }] : void 0
+              artifacts: videoPath ? [{ type: "video", name: path22.basename(videoPath), path: videoPath }] : void 0
             };
           } finally {
             try {
@@ -39744,8 +39984,8 @@ var skill4 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path21 = await import("path");
-        const fs21 = await import("fs");
+        const path22 = await import("path");
+        const fs22 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -39771,9 +40011,9 @@ var skill4 = {
             ...profile,
             fps: syncCount > 0 ? (syncCount / (duration / 1e3)).toFixed(1) : "0"
           };
-          const reportPath = path21.join(context.outputDir, "perf-report.json");
-          fs21.mkdirSync(path21.dirname(reportPath), { recursive: true });
-          fs21.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+          const reportPath = path22.join(context.outputDir, "perf-report.json");
+          fs22.mkdirSync(path22.dirname(reportPath), { recursive: true });
+          fs22.writeFileSync(reportPath, JSON.stringify(report, null, 2));
           return {
             success: true,
             message: `${report.fps} fps, ${profile.avgSyncMs?.toFixed(1)}ms avg sync, ${nodeCount} nodes`,
@@ -39806,8 +40046,8 @@ var skill5 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path21 = await import("path");
-        const fs21 = await import("fs");
+        const path22 = await import("path");
+        const fs22 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -39815,8 +40055,8 @@ var skill5 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const outputPath = path21.join(context.outputDir, `${params.name}.png`);
-          fs21.mkdirSync(path21.dirname(outputPath), { recursive: true });
+          const outputPath = path22.join(context.outputDir, `${params.name}.png`);
+          fs22.mkdirSync(path22.dirname(outputPath), { recursive: true });
           await page.screenshot({ path: outputPath });
           return {
             success: true,
@@ -39857,8 +40097,8 @@ var skill6 = {
       },
       async execute(params, context) {
         const { chromium } = await import("playwright");
-        const path21 = await import("path");
-        const fs21 = await import("fs");
+        const path22 = await import("path");
+        const fs22 = await import("fs");
         const browser = await launchReapedChrome((options) => chromium.launch(options), {
           headless: true
         });
@@ -39866,14 +40106,14 @@ var skill6 = {
         try {
           await page.goto(context.url, { waitUntil: "networkidle" });
           await page.waitForTimeout(2e3);
-          const currentPath = path21.join(context.outputDir, `${params.name}-current.png`);
-          fs21.mkdirSync(path21.dirname(currentPath), { recursive: true });
+          const currentPath = path22.join(context.outputDir, `${params.name}-current.png`);
+          fs22.mkdirSync(path22.dirname(currentPath), { recursive: true });
           await page.screenshot({ path: currentPath });
           try {
             const { PNG } = await import("pngjs");
             const pixelmatch = (await import("pixelmatch")).default;
-            const baseline = PNG.sync.read(fs21.readFileSync(params.baseline));
-            const current = PNG.sync.read(fs21.readFileSync(currentPath));
+            const baseline = PNG.sync.read(fs22.readFileSync(params.baseline));
+            const current = PNG.sync.read(fs22.readFileSync(currentPath));
             const { width, height } = baseline;
             const diff = new PNG({ width, height });
             const numDiffPixels = pixelmatch(
@@ -39884,8 +40124,8 @@ var skill6 = {
               height,
               { threshold: params.threshold || 0.1 }
             );
-            const diffPath = path21.join(context.outputDir, `${params.name}-diff.png`);
-            fs21.writeFileSync(diffPath, PNG.sync.write(diff));
+            const diffPath = path22.join(context.outputDir, `${params.name}-diff.png`);
+            fs22.writeFileSync(diffPath, PNG.sync.write(diff));
             const totalPixels = width * height;
             const diffPercent = (numDiffPixels / totalPixels * 100).toFixed(2);
             return {
@@ -39949,10 +40189,10 @@ var skillRegistry = {
   },
   // load skills from a project manifest (rnx-skills.json)
   async loadFromManifest(projectDir) {
-    const manifestPath = path20.join(projectDir, "rnx-skills.json");
-    if (!fs20.existsSync(manifestPath)) return;
+    const manifestPath = path21.join(projectDir, "rnx-skills.json");
+    if (!fs21.existsSync(manifestPath)) return;
     try {
-      const manifest = JSON.parse(fs20.readFileSync(manifestPath, "utf8"));
+      const manifest = JSON.parse(fs21.readFileSync(manifestPath, "utf8"));
       if (Array.isArray(manifest.skills)) {
         for (const entry of manifest.skills) {
           if (typeof entry === "string") {
@@ -39963,7 +40203,7 @@ var skillRegistry = {
             }
           } else if (entry.file) {
             try {
-              const mod = await import(path20.resolve(projectDir, entry.file));
+              const mod = await import(path21.resolve(projectDir, entry.file));
               if (mod.skill) this.register(mod.skill);
             } catch {
             }
@@ -39976,10 +40216,10 @@ var skillRegistry = {
   // auto-discover skills based on project dependencies
   suggestSkills(projectDir) {
     const suggestions = [];
-    const pkgPath = path20.join(projectDir, "package.json");
-    if (!fs20.existsSync(pkgPath)) return suggestions;
+    const pkgPath = path21.join(projectDir, "package.json");
+    if (!fs21.existsSync(pkgPath)) return suggestions;
     try {
-      const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (deps["detox"] || deps["maestro"]) {
         suggestions.push("maestro-test");