sootsim 0.1.138 → 0.1.140

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.138 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.140 | (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;
@@ -1078,10 +1078,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=3.0.0",
-            coverage: 0.4,
-            note: "OffscreenCanvas produces a real PNG/JPG/WebP blob URL at the requested dimensions, validateOptions mirrors upstream src/index.tsx warning text, ViewShot exposes capture() on the inner ref with mount/continuous/update captureMode, tmpfile mode tracks blob URLs for releaseCapture revocation. BUT the captured pixels are a placeholder diagonal pattern, not the actual view tree \u2014 apps that share / upload / display the result get a placeholder image, not their UI. The primary purpose (visual capture of the rendered view) is not satisfied \u2014 would need CanvasKit pixel readback through the engine bridge.",
-            working: "captureRef/captureScreen returning a real blob URL/base64/data-uri at the right dimensions and format, validateOptions parity with upstream warning text, all format types (png/jpg/webp/webm\u2192webp/raw\u2192png), quality forwarding for lossy formats, ViewShot component with capture() ref method, captureMode mount/continuous/update, releaseCapture revoking tracked blob URLs",
-            missing: "real pixel content matching the view tree (placeholder pattern instead \u2014 the primary purpose of the package), zip-base64 falls back to plain base64, raw format falls back to png"
+            coverage: 0.82,
+            note: "captureRef/captureScreen now return REAL captured pixels: the tenant resolves the target node's absolute rect (unstable_getBoundingClientRect) and asks the shell \u2014 the only context that paints the visible app pixels \u2014 to crop that region of the active app surface and re-encode it (viewShot.capture round-trip over the native-UI bus \u2192 shell-side 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 the shell can't sample the surface (no painted pixels, fully out of bounds, or a non-shell worker mode), 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 shell 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)"
           }
         ]
       },
@@ -1221,10 +1221,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=18.0.0",
-            coverage: 0.25,
-            note: "noop Firestore reference/query API \u2014 CRUD methods resolve with empty snapshots",
-            working: "default firestore(), getFirestore, collection/doc refs, set/update/delete/get, collection.get empty snapshot, onSnapshot unsubscribe, batch commit, FieldValue helpers",
-            missing: "real document storage, query filtering/order/limit semantics, realtime sync, transactions, offline persistence"
+            coverage: 0.6,
+            note: "upstream @react-native-firebase/firestore JS runs unchanged against noop RNFBFirestore{,Collection,Document,Transaction}Module native seams \u2014 reads resolve empty snapshots, writes resolve, listeners never emit",
+            working: "full public API surface from the real package: default firestore(), getFirestore, modular helpers, collection/doc references, queries with where/orderBy/limit modifiers, get() returning structurally-correct empty document/query snapshots, set/update/delete/batch resolving, onSnapshot unsubscribe, count/aggregate (0), transactions, write batches, FieldValue/FieldPath/Timestamp/GeoPoint statics, settings/network/persistence/emulator config",
+            missing: "real document storage, query filtering/order/limit results, realtime sync events, transaction read-modify-write semantics, offline persistence"
           }
         ]
       },
@@ -1273,10 +1273,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=18.0.0",
-            coverage: 0.25,
-            note: "noop Storage refs \u2014 upload/download metadata calls resolve without cloud storage",
-            working: "default storage(), ref/refFromURL, child refs, put/putFile success snapshots, getDownloadURL stub URI, metadata/list/delete methods",
-            missing: "real upload/download bytes, resumable tasks, progress events, Firebase Storage rules/auth integration"
+            coverage: 0.55,
+            note: "upstream @react-native-firebase/storage JS runs unchanged against a noop RNFBStorageModule native seam \u2014 uploads resolve a success snapshot without moving bytes, reads resolve empty metadata/lists",
+            working: "full public API surface from the real package: default storage(), ref/refFromURL, child/parent refs, put/putString/putFile/writeToFile upload+download tasks resolving success snapshots, StorageTask pause/resume/cancel, getDownloadURL stub URI, getMetadata/updateMetadata structurally-correct empty metadata, list/listAll empty results, delete, retry-time constants and setters, emulator config",
+            missing: "real upload/download bytes, resumable tasks, live progress events, Firebase Storage rules/auth integration"
           }
         ]
       },
@@ -1377,10 +1377,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=10.0.0",
-            coverage: 0.4,
-            note: "placeholder map surface; camera and shape layers are noops",
-            working: "MapView (placeholder render, ref API), Camera (setCamera/fitBounds), ShapeSource, LineLayer, CircleLayer, SymbolLayer, FillLayer, MarkerView, PointAnnotation, UserLocation, Images, setAccessToken",
-            missing: "no tile rendering, no real geo interaction, onMapIdle/onDidFinishLoadingMap fire but shapes are invisible"
+            coverage: 0.7,
+            note: "real maplibre tiles via the host native seam (map-host.ts). the package JS runs from the bundle; RNMBX* host components + the RNMBXModule native module are seam-provided. keyless: mapbox:// styles fall back to OpenFreeMap.",
+            working: "MapView (real vector tiles, pinch-zoom + pan), Camera (centerCoordinate/zoomLevel/bounds/pitch/heading via the stop prop \u2192 camera/fit), ShapeSource (geojson), LineLayer/CircleLayer/FillLayer/SymbolLayer/HeatmapLayer/FillExtrusionLayer/BackgroundLayer (reactStyle \u2192 GL paint/layout), PointAnnotation/MarkerView (host pin), setAccessToken/setWellKnownTileServer (no-op, keyless)",
+            missing: "custom PointAnnotation/MarkerView child views (need host\u2192tenant coordinate projection), imperative queries (queryRenderedFeaturesAtPoint/getZoom/getCenter/takeSnap), raster/vector/image tile sources, terrain/sky/atmosphere, real onCameraChanged/onMapIdle payloads"
           }
         ]
       },
@@ -1479,10 +1479,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=1.0.0",
-            coverage: 0.7,
-            note: "real OpenStreetMap-tile rendering via the standard /export/embed.html iframe (https://wiki.openstreetmap.org/wiki/Export#Embeddable_HTML). bbox computed from initialRegion/region (latitudeDelta + longitudeDelta around the center), marker at the region center, getCamera derives zoom from latitudeDelta via log2(360/delta), getMapBoundaries returns the real region rectangle. Pan/zoom UI is provided by OSM. onMapReady fires on iframe load. Polyline/Polygon/Circle/Marker/Overlay still render null because OSM embed has no overlay API \u2014 would need Leaflet bundled in to add them.",
-            working: "MapView with real OSM tile rendering, initialRegion/region honored, getCamera/getMapBoundaries returning real region-derived values, onMapReady firing on iframe load, MapView ref API surface, Marker/Callout/CalloutSubview/AnimatedRegion/MAP_TYPES/PROVIDER_GOOGLE/DEFAULT/enableLatestRenderer exports",
-            missing: "overlay components (Polyline/Polygon/Circle/Overlay/Heatmap/Geojson/UrlTile/WMSTile/LocalTile, Marker visuals \u2014 would need Leaflet integration), pan/zoom callbacks (onRegionChange) since we cannot intercept OSM embed events from the parent frame, showsUserLocation tracking, animateToRegion / animateCamera with smooth animation, takeSnapshot, gesture-based onPress / onLongPress"
+            coverage: 0.82,
+            note: "native-seam over a real host-thread maplibre-gl driver (render-worker/map-host.ts), NOT an OSM iframe. the package JS (MapView/Marker/Callout/AnimatedRegion/createFabricMap) runs unchanged; only the RNMapsMapView/RNMapsMarker host components + the RNMapsAirModule TurboModule are ours. maplibre renders keyless OpenFreeMap vector tiles at device scale on the host and ships each frame to the shell painter via the live-frame channel. Markers render as real maplibre circle layers. Pinch (focal-point zoom) + pan are forwarded from the tenant responder. The imperative ref API now works: getCamera/getMapBoundaries/getPointForCoordinate/getCoordinateForPoint answer from web-mercator math over the seam's tracked camera; animateCamera/animateToRegion/setCamera/fitToCoordinates/fitToElements route through codegenNativeCommands \u2192 __dispatchCommandImpl \u2192 the maplibre easeTo/jumpTo/fitBounds host commands. getCamera reflects the LAST COMMANDED camera (programmatic drive), not gesture-driven changes \u2014 there's no onRegionChange feedback channel yet.",
+            working: "MapView with real maplibre vector-tile rendering at device scale, initialRegion/region/camera honored, Marker (real map pins via maplibre circle layers, pinColor), pinch+pan gestures with focal-point zoom, getCamera/getMapBoundaries (web-mercator unproject of the view corners), getPointForCoordinate/getCoordinateForPoint (projection round-trip), getMarkersFrames, animateCamera/animateToRegion/setCamera (easeTo/jumpTo), fitToCoordinates/fitToElements/fitToSuppliedMarkers (fitBounds), onMapReady, MapView ref API, Callout/CalloutSubview/AnimatedRegion/MAP_TYPES/PROVIDER_GOOGLE/DEFAULT/enableLatestRenderer exports",
+            missing: "onRegionChange/onRegionChangeComplete (no feedback channel from the host map back to the tenant, so getCamera is stale after a user gesture), custom Marker child views (coordinate-only pins today), shape overlays (Polyline/Polygon/Circle/Overlay/Heatmap/Geojson/UrlTile/WMSTile/LocalTile render null \u2014 the GL style reconcile path exists in map-host but react-native-maps does not emit it yet, only @rnmapbox/maps does), takeSnapshot (map pixels render host-side \u2014 needs a snapshot round-trip), getAddressFromCoordinates (no reverse geocoder), showsUserLocation tracking, gesture-based onPress/onLongPress"
           }
         ]
       },
@@ -1916,10 +1916,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=4.0.0",
-            coverage: 0.75,
-            note: "Android-only; tracks requested navigation-bar state and modern component/static API shape",
-            working: "NavigationBar component with setStyle/setHidden statics, set/get background color, set border/position/behavior/translucent, setVisibilityAsync/getVisibilityAsync, visibility listeners, useVisibility, button style APIs",
-            missing: "real Android system-bar mutation, OS contrast enforcement, actual navigation-bar dimensions/insets, emulator-specific behavior"
+            coverage: 0.85,
+            note: "Android-only; full modern component/static API that drives the rendered Android navigation bar through the engine systemBars bridge (visibility, color, style, translucency feed the shell nav-bar + safe-area insets)",
+            working: "NavigationBar component with setStyle/setHidden statics, set/get background color, set border/position/behavior/translucent, setVisibilityAsync/getVisibilityAsync, visibility listeners + emitted change events, useVisibility hook, button style APIs; all setters publish to getEngineConfig().systemBars so android-system-bars.tsx actually shows/hides/tints the rendered nav bar and updates navigation-bar height/insets; non-Android runtimes return the upstream unavailable values",
+            missing: "OS contrast enforcement, exact per-emulator nav-bar pixel dimensions"
           }
         ]
       },
@@ -1929,10 +1929,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=14.0.0",
-            coverage: 0.75,
-            note: 'only `window.print()` is real (printAsync routes through it for browser print dialog). PDF-output APIs are mocked \u2014 printToFileAsync returns a fabricated `uri: "mock://print.pdf"` with empty `base64`, so apps that upload/share/preview the returned URI silently break.',
-            working: "upstream validation and concurrency guard, printAsync (real window.print), printToFileAsync (stable URI/numberOfPages/base64 shape), selectPrinterAsync, Orientation enum",
-            missing: "printToFileAsync produces `mock://print.pdf` + empty base64 instead of real PDF bytes (would need a worker-side PDF encoder); any consumer that uploads the URI, decodes the base64, or feeds it into a share/preview flow gets a non-PDF. native printer selection / AirPrint sheet unavailable in browser."
+            coverage: 0.8,
+            note: "printAsync routes through real window.print() (browser print dialog). printToFileAsync now produces a REAL, structurally-valid PDF (verified by `file`/macOS as com.adobe.pdf) carrying the html's text content + a real page count, written to the same in-memory cache the expo-file-system stub serves \u2014 so the returned `file:///sootsim-cache/Print/*.pdf` URI resolves to genuine PDF bytes (readAsStringAsync / FormData upload / Sharing / Print preview all work), and base64 (when requested) decodes to those bytes. This replaces the old `mock://print.pdf` dangling URI that broke every consumer. Fidelity caveat: the worker has no WebView render engine, so the PDF reproduces the document's TEXT (paginated, escaped) but NOT CSS/image layout \u2014 a degraded-but-real simulation of iOS's WKWebView\u2192UIPrintPageRenderer output.",
+            working: "upstream validation and concurrency guard, printAsync (real window.print), printToFileAsync (real PDF bytes: %PDF header, catalog/pages tree, xref, paginated text content, real numberOfPages, real file:// uri + base64), selectPrinterAsync, Orientation enum",
+            missing: "CSS/image/font layout fidelity in the generated PDF (text-only render \u2014 needs a worker WebView engine to match WKWebView pixel output), useMarkupFormatter (same text path), printerUrl/AirPrint physical printing, native printer selection sheet (selectPrinterAsync returns undefined)"
           }
         ]
       },
@@ -2185,10 +2185,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=4.6.1",
-            coverage: 0.65,
-            note: "simple CanvasKit blur/liquid-glass approximation for latest native component exports",
-            working: "BlurView, VibrancyView, ProgressiveBlurView, LiquidGlassView, LiquidGlassContainer, BlurSwitch, native component export aliases",
-            missing: "true native progressive gradient blur, exact iOS 26 liquid glass behavior, Android QmBlurView behavior, native switch event payload fidelity, reduced transparency system setting integration"
+            coverage: 0.7,
+            note: "CanvasKit backdrop-blur + engine liquid-glass material for the full latest component surface; 40-material iOS color table drives per-blurType overlay tint",
+            working: "BlurView/VibrancyView/ProgressiveBlurView render real backdropFilter (sigma from blurAmount) over a per-material rgba overlay from the full iOS material constant table (xlight\u2026systemChromeMaterialDark); LiquidGlassView/LiquidGlassContainer drive the engine _liquidGlass material (glassType, parsed tintColor, opacity, cornerRadius); BlurSwitch is a real interactive switch (value/onValueChange/disabled, switch a11y role+state, track color); all native component export aliases",
+            missing: "progressive gradient direction (direction/startOffset accepted but ignored \u2014 renders uniform blur), exact iOS 26 liquid glass behavior, Android QmBlurView behavior, reduced-transparency system-setting fallback color"
           }
         ]
       },
@@ -2276,10 +2276,10 @@ var init_registry = __esm({
         versions: [
           {
             range: ">=6.0.0",
-            coverage: 0.1,
-            note: "all zip/unzip operations are noops \u2014 no browser ZIP impl",
-            working: "API shape present (zip, unzip, unzipAssets, zipWithPassword, subscribe, isPasswordProtected, getUncompressedSize), path constants, subscribe returns removable listener",
-            missing: "zip (noop), unzip (noop), unzipAssets (noop), zipWithPassword (noop), isPasswordProtected always false, getUncompressedSize always 0 \u2014 no actual compression/decompression"
+            coverage: 0.6,
+            note: "real zip/unzip via fflate over the shared compat VFS; only password/AES variants unsupported (no browser zip-crypto codec)",
+            working: "zip/zipFolder/zipFiles (real DEFLATE, basename + folder-relative entries), unzip (real inflate to VFS), isPasswordProtected (reads GP encryption bit), getUncompressedSize (sums central-directory sizes, -1 on parse error), zipArchiveProgressEvent (0%/per-entry/100%) into subscribe()",
+            missing: "zipWithPassword / unzipWithPassword / zipFilesWithPassword / zipFolderWithPassword \u2014 fflate has no ZipCrypto/AES codec, so these reject with the native zip_error/unzip_error shape; unzipAssets (no native asset bundle); unzip of an encrypted archive rejects"
           }
         ]
       },
@@ -9343,6 +9343,408 @@ var init_registry = __esm({
             missing: "no HealthKit data store, permission prompt, authorization state, observer events, native input validation, or persisted writes in the browser simulator"
           }
         ]
+      },
+      // ── lane A2: ranks 751-1000, native-filtered zero-scorers lifted ──
+      // pure-JS mis-flags: no real native module on iOS, run as-is from the bundle.
+      "rn-css": {
+        category: "UI Components",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=2.0.0",
+            coverage: 0.95,
+            note: "pure JS \u2014 styled-components-style css template tag over RN primitives; no native modules, runs as-is from the bundle",
+            working: "styled.View/Text/etc, css template literals, theme provider, media queries, units, inline style resolution",
+            missing: "nothing native to provide \u2014 any gap is the pure-JS surface itself, not a missing native seam"
+          }
+        ]
+      },
+      "react-native-gauge": {
+        category: "UI Components",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.95,
+            note: "pure JS \u2014 composes react-native-progress + masked-view + expo-linear-gradient + Animated; no native modules, runs as-is from the bundle",
+            working: "Gauge component, animated needle, gradient fill, triangle tip/base, circle indicator \u2014 all JS-rendered",
+            missing: "no native module \u2014 fidelity is bounded only by the underlying JS rendering libraries"
+          }
+        ]
+      },
+      "react-native-material-you-colors": {
+        category: "UI Components",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.95,
+            note: "pure JS on iOS \u2014 the Monet palette generator runs in JS; the native module is android-only (isMaterialYouSupported=false, getPalletteFromAndroid=null on iOS)",
+            working: "MaterialYou.generatePaletteFromColor, createThemeContext, useMaterialYouTheme, Palette/Monet algorithm, isSupported=false on iOS",
+            missing: "dynamic system-wallpaper palette extraction (android-12+ only) \u2014 iOS has no system Material You source, matching upstream"
+          }
+        ]
+      },
+      "react-native-shake-event": {
+        category: "Device & Platform",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.9,
+            note: "pure JS \u2014 addEventListener wires a DeviceEventEmitter listener for 'ShakeEvent'; no native module method is called, so it runs as-is and the shake event simply never fires in the simulator (correct: no shake gesture)",
+            working: "RNShakeEvent.addEventListener/removeEventListener for the shake event",
+            missing: "no device shake gesture in the simulator, so the listener never fires \u2014 matching the absence of a real accelerometer"
+          }
+        ]
+      },
+      // native-seam only: real package JS runs from the bundle; SootSim registers the
+      // named TurboModule/NativeModule as a structurally-correct noop.
+      // rudderstack device-mode analytics integrations — each is a one-line
+      // `NativeModules.RudderIntegration<Name>ReactNative.setup()` wrapper. delivery
+      // intentionally absent per docs/compat-scoring.md.
+      "@rudderstack/rudder-integration-facebook-react-native": {
+        category: "Analytics",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the setup() wrapper runs from the bundle; RudderIntegrationFacebookReactNative.setup() is a noop. delivery intentionally absent in browser preview.",
+            working: "default setup() resolves; device-mode registration accepted without throwing",
+            missing: "no Facebook SDK delivery \u2014 same constraint as every analytics integration in browser preview"
+          }
+        ]
+      },
+      "@rudderstack/rudder-integration-clevertap-react-native": {
+        category: "Analytics",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the setup() wrapper runs from the bundle; RudderIntegrationCleverTapReactNative.setup() is a noop. delivery intentionally absent in browser preview.",
+            working: "default setup() resolves; device-mode registration accepted without throwing",
+            missing: "no CleverTap SDK delivery \u2014 same constraint as every analytics integration in browser preview"
+          }
+        ]
+      },
+      "@rudderstack/rudder-integration-singular-react-native": {
+        category: "Analytics",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the setup() wrapper runs from the bundle; RudderIntegrationSingularReactNative.setup() is a noop. delivery intentionally absent in browser preview.",
+            working: "default setup() resolves; device-mode registration accepted without throwing",
+            missing: "no Singular SDK delivery \u2014 same constraint as every analytics integration in browser preview"
+          }
+        ]
+      },
+      "@rudderstack/rudder-integration-braze-react-native": {
+        category: "Analytics",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the setup() wrapper runs from the bundle; RudderIntegrationBrazeReactNative.setup() is a noop. delivery intentionally absent in browser preview.",
+            working: "default setup() resolves; device-mode registration accepted without throwing",
+            missing: "no Braze SDK delivery \u2014 same constraint as every analytics integration in browser preview"
+          }
+        ]
+      },
+      "@rudderstack/rudder-integration-amplitude-react-native": {
+        category: "Analytics",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the setup() wrapper runs from the bundle; RudderIntegrationAmplitudeReactNative.setup() is a noop. delivery intentionally absent in browser preview.",
+            working: "default setup() resolves; device-mode registration accepted without throwing",
+            missing: "no Amplitude SDK delivery \u2014 same constraint as every analytics integration in browser preview"
+          }
+        ]
+      },
+      "react-native-apple-ads-attribution": {
+        category: "Analytics",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the AppleAdsAttribution JS class runs from the bundle; RNAppleAdsAttribution.getAttributionData() resolves {} (exactly what the real iOS module returns on the no-attribution/error path). attribution data intentionally absent.",
+            working: "getAttributionData() resolves an empty object",
+            missing: "no Apple Search Ads attribution payload in the simulator \u2014 matches the real iOS module resolving {} when attribution is unavailable"
+          }
+        ]
+      },
+      "@logicwind/react-native-matomo-tracker": {
+        category: "Analytics",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the tracker JS API runs from the bundle; ReactNativeMatomoTracker exposes all track*/createTracker/session/dimension methods as noops. delivery intentionally absent in browser preview.",
+            working: "createTracker, trackScreen/Event/Goal/Search/Outlink/Download/Impression/Interaction/Media/Campaign/CustomDimension, trackDispatch, set/disable/enable tracking, setUserId/VisitorId, startSession, setLogger",
+            missing: "no Matomo delivery \u2014 same constraint as every analytics SDK in browser preview"
+          }
+        ]
+      },
+      "react-native-appearance-control": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the JS wrapper runs from the bundle; the AppearanceControl TurboModule accepts setAppearanceDark/Light/System as noops",
+            working: "setAppearanceDark(), setAppearanceLight(), setAppearanceSystem() resolve",
+            missing: "no runtime override of the host appearance in the simulator \u2014 calls resolve without changing the canvas color scheme"
+          }
+        ]
+      },
+      "rn-date-format": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the JS wrapper runs from the bundle; the DeviceTimeFormat TurboModule's is24HourFormat() returns false (the iOS-default 12-hour reading)",
+            working: "is24HourFormat() returns a boolean",
+            missing: "no per-device locale time-format reading in the simulator \u2014 returns the 12-hour default"
+          }
+        ]
+      },
+      "react-native-app-review": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the JS wrapper runs from the bundle; the AppReview native module exposes launch() as a noop (no StoreKit review prompt in the simulator)",
+            working: "AppReview.launch() accepted",
+            missing: "no SKStoreReviewController prompt in the simulator \u2014 launch() is a noop, matching the OS rate-limiting/no-op the real API has in most contexts"
+          }
+        ]
+      },
+      // ── Lane A1b: pure-JS mis-flagged (no stub — real package runs from bundle) ──
+      "react-native-cardview": {
+        category: "UI Components",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.95,
+            note: "pure JS on iOS \u2014 CardView.ios.js renders a plain <View> with shadow/borderRadius styles; the native RNCardView is Android-only, never touched on the iOS-shaped simulator",
+            working: "CardView with cardElevation/cornerRadius/shadowOpacity mapped to View shadow styles"
+          }
+        ]
+      },
+      "@klarna/react-native-vector-drawable": {
+        category: "Image",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.95,
+            note: "pure JS on iOS \u2014 index.ios.js is `export { View as default } from 'react-native'`; the native RNVectorDrawable component is Android-only and never resolved on the simulator",
+            working: "VectorDrawable degrades to a plain RN View on iOS (matching upstream Android-only native)"
+          }
+        ]
+      },
+      "react-native-image-mapper": {
+        category: "UI Components",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.95,
+            note: "pure JS \u2014 image overlay built from ImageBackground + TouchableOpacity hotspots, no ios/ or android/ native code at all",
+            working: "ImageMapper, clickable mapping areas over an image, onPress per area"
+          }
+        ]
+      },
+      "react-native-basic-carousel": {
+        category: "UI Components",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.95,
+            note: "pure JS \u2014 the Carousel component is an Animated.FlatList with pagination; the package only references NativeModules.RNBasicCarouselModule for a vestigial default export (undefined on the simulator, load-safe)",
+            working: "Carousel (data/renderItem/itemWidth/pagination/autoplay), snap-to-item, paging, pagination dots"
+          }
+        ]
+      },
+      "react-native-insta-story": {
+        category: "UI Components",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.95,
+            note: 'pure JS \u2014 Story component built on modal + swipe gestures; the bundled InstaStory native module is an unimplemented placeholder (a red "*****" UILabel) that the JS never imports',
+            working: "InstaStory list, per-story progress, swipe between users, tap to advance"
+          }
+        ]
+      },
+      "react-native-in-app-updates": {
+        category: "Device & Platform",
+        stubType: "works",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.95,
+            note: 'load-safe on iOS \u2014 upstream guards the missing native module with a Proxy and every method short-circuits to `Promise.reject("only available on Android")`, exactly the clean unavailable state an app expects on iOS',
+            working: "checkNeedsUpdate / startUpdate / addStatusUpdateListener importable; iOS calls reject with the Android-only error (matching real device behavior)"
+          }
+        ]
+      },
+      // ── Lane A1b: native-seam only (real pure-JS package runs from the bundle) ──
+      "react-native-xxhash": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.95,
+            note: "native-seam only \u2014 the real JS runs from the bundle; the xxhash JSI install() mounts faithful XXH3-64/128 implementations (bit-exact vs upstream xxhash 0.8.3)",
+            working: "hash64 / hash128 (globalThis.__xxhash64 / __xxhash128) \u2014 deterministic, matches the native C++ digest"
+          }
+        ]
+      },
+      "react-native-ulid-jsi": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.95,
+            note: "native-seam only \u2014 the real JS runs from the bundle; the RNUlid JSI install() mounts a faithful ULID spec implementation (Crockford base32, 48-bit time, monotonic)",
+            working: "getUlid / checkIsValid / decodeTime (globalThis.__getUlid / __checkIsValid / __decodeTime)"
+          }
+        ]
+      },
+      "react-native-nitro-buffer": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.9,
+            note: "native-seam only \u2014 the Buffer JS class runs from the bundle; the NitroBuffer Nitro hybrid mirrors the upstream C++ byte ops faithfully (deterministic, no native dependency)",
+            working: "alloc/allocUnsafe, byteLength, write/decode (utf8/utf16le/latin1/ascii/hex/base64/base64url), compare, fill, indexOf/lastIndexOf"
+          }
+        ]
+      },
+      "react-native-nitro-geocoder": {
+        category: "Maps",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=1.0.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the JS runs from the bundle; the NitroGeocoder hybrid implements calculateDistance (faithful Haversine) and reports geocoding unavailable (no CLGeocoder in the simulator)",
+            working: "calculateDistance (real great-circle distance), isGeocodingAvailable=false",
+            missing: "geocode / reverseGeocode reject (CLGeocoder unavailable in the simulator \u2014 matches the no-results native path)"
+          }
+        ]
+      },
+      "react-native-video-duration": {
+        category: "Media",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the JS runs from the bundle; VideoDuration.getVideoDuration() resolves 0 (no AVAsset in the simulator; upstream maps non-positive durations to 0)",
+            working: "getVideoDuration importable + resolves cleanly",
+            missing: "no real AVFoundation duration probe in the simulator"
+          }
+        ]
+      },
+      "@meedwire/react-native-image-rotate": {
+        category: "Image",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the JS runs from the bundle; ImageRotate.rotate() returns the source content unchanged (no native pixel rotation in the simulator)",
+            working: "rotate({content,type,angle}) resolves a string uri",
+            missing: "pixels are not actually rotated in the simulator"
+          }
+        ]
+      },
+      "react-native-tiktok": {
+        category: "Auth & Payments",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the JS runs from the bundle; Tiktok.authorize() invokes its callback with the no-auth shape (no TikTok OAuth handoff in the simulator)",
+            working: "authorize importable + callback invoked, Scopes constants",
+            missing: "no real TikTok login (the simulator has no native TikTok SDK app-switch)"
+          }
+        ]
+      },
+      "react-native-store-age-signals-native-modules": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.7,
+            note: "native-seam only \u2014 the JS runs from the bundle; the native module resolves the all-null declared-age-range result (the Declared Age Range SDK is unavailable, matching upstream non-iOS fallback)",
+            working: "requestIOSDeclaredAgeRange / getAndroidPlayAgeRangeStatus resolve the documented null result shape",
+            missing: "no real StoreKit age-signal lookup in the simulator"
+          }
+        ]
+      },
+      "react-native-widget-picker": {
+        category: "Device & Platform",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.85,
+            note: "native-seam only \u2014 the JS runs from the bundle; WidgetPickerModule reports unsupported (home-screen widget pinning is Android-only, matching upstream index.ios.ts)",
+            working: "isRequestPinAppWidgetSupported()=false, requestPinAppWidget() resolves the not-supported message"
+          }
+        ]
+      },
+      "react-native-appstack-sdk": {
+        category: "Analytics",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.85,
+            note: "native-seam only \u2014 the JS runs from the bundle; the AppstackReactNative attribution/event TurboModule is a load-safe noop. delivery intentionally absent in the simulator",
+            working: "configure, sendEvent, enableAppleAdsAttribution, getAppstackId, isSdkDisabled, getAttributionParams (all resolve cleanly)",
+            missing: "no network attribution delivery from the simulator"
+          }
+        ]
+      },
+      "react-native-fcm": {
+        category: "Notifications",
+        stubType: "native",
+        versions: [
+          {
+            range: ">=0.1.0",
+            coverage: 0.85,
+            note: "native-seam only \u2014 the real JS runs from the bundle; the RNFIRMessaging native module is a load-safe noop (synthetic token, no events). delivery intentionally absent in the simulator",
+            working: "getFCMToken/getAPNSToken (synthetic token), local-notification + topic + badge plumbing importable and resolve cleanly",
+            missing: "no real push delivery or token registration from the simulator"
+          }
+        ]
       }
     };
   }
@@ -9632,815 +10034,47 @@ var init_native_dev_bundle_url = __esm({
   }
 });
 
-// scripts/demo-app-registry.ts
-var demo_app_registry_exports = {};
-__export(demo_app_registry_exports, {
-  APPS: () => APPS
+// scripts/optional-demo-registry.ts
+var optional_demo_registry_exports = {};
+__export(optional_demo_registry_exports, {
+  loadOptionalDemoApps: () => loadOptionalDemoApps,
+  optionalDemoAppsSync: () => optionalDemoAppsSync
 });
-function findWorkspaceRoot(startDir) {
-  let dir = startDir;
-  while (true) {
-    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "pnpm-workspace.yaml")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "turbo.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "nx.json")) || (0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "lerna.json"))) {
-      return dir;
-    }
-    const packageJsonPath = (0, import_node_path.join)(dir, "package.json");
-    if ((0, import_node_fs.existsSync)(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf8"));
-        if (pkg.workspaces) return dir;
-      } catch {
-      }
-    }
-    const parent = (0, import_node_path.dirname)(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function resolveWorkspaceScriptPath(workspaceRelativePath, packageRelativePath) {
-  const workspaceRoot = findWorkspaceRoot(process.cwd());
-  const candidates = [
-    workspaceRoot ? (0, import_node_path.resolve)(workspaceRoot, workspaceRelativePath) : null,
-    (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath),
-    (0, import_node_path.resolve)(process.cwd(), packageRelativePath)
-  ].filter((candidate) => Boolean(candidate));
-  for (const candidate of candidates) {
-    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
-  }
-  return candidates[0] ?? (0, import_node_path.resolve)(process.cwd(), workspaceRelativePath);
-}
-function parseEnvFile(filePath) {
-  if (!(0, import_node_fs.existsSync)(filePath)) return {};
-  const env = {};
-  const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
-  for (const rawLine of source.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
-    if (!match) continue;
-    let value = match[2].trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    env[match[1]] = value;
-  }
-  return env;
-}
-function isUsableUniswapEnvValue(value) {
-  if (!value) return false;
-  const trimmed = value.trim();
-  if (!trimmed) return false;
-  if (trimmed.includes(UNISWAP_PLACEHOLDER)) return false;
-  if (trimmed === "TRADING_API_KEY" || trimmed === "UNISWAP_API_KEY") return false;
-  return true;
-}
-function pickEnvValue(sources, keys) {
-  for (const source of sources) {
-    for (const key of keys) {
-      const value = source[key];
-      if (isUsableUniswapEnvValue(value)) return value.trim();
-    }
-  }
-  return void 0;
-}
-function resolveUniswapDemoEnv() {
-  const localEnv = parseEnvFile(UNISWAP_ENV_LOCAL_FILE);
-  const webEnv = parseEnvFile((0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/web/.env"));
-  const sources = [
-    process.env,
-    localEnv,
-    webEnv
-  ];
-  const env = {};
-  const bindings = [
-    ["AMPLITUDE_PROXY_URL_OVERRIDE", ["REACT_APP_AMPLITUDE_PROXY_URL"]],
-    ["QUICKNODE_ENDPOINT_NAME", ["REACT_APP_QUICKNODE_ENDPOINT_NAME"]],
-    ["QUICKNODE_ENDPOINT_TOKEN", ["REACT_APP_QUICKNODE_ENDPOINT_TOKEN"]],
-    ["INFURA_KEY", ["REACT_APP_INFURA_KEY"]],
-    ["STATSIG_API_KEY", ["REACT_APP_STATSIG_API_KEY"]],
-    ["STATSIG_PROXY_URL_OVERRIDE", ["REACT_APP_STATSIG_PROXY_URL"]],
-    ["WALLETCONNECT_PROJECT_ID", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
-    ["WALLETCONNECT_PROJECT_ID_BETA", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
-    ["WALLETCONNECT_PROJECT_ID_DEV", ["REACT_APP_WALLET_CONNECT_PROJECT_ID"]],
-    ["TRADING_API_KEY", ["REACT_APP_TRADING_API_KEY"]],
-    ["UNISWAP_API_KEY", []]
-  ];
-  for (const [target, aliases] of bindings) {
-    const value = pickEnvValue(sources, [target, ...aliases]);
-    if (!value) continue;
-    env[target] = value;
-    for (const alias of aliases) {
-      env[alias] = value;
-    }
-  }
-  const hasPrivateGatewayKeys = isUsableUniswapEnvValue(env.TRADING_API_KEY) && isUsableUniswapEnvValue(env.UNISWAP_API_KEY);
-  if (!hasPrivateGatewayKeys) {
-    const publicGraphqlUrl = pickEnvValue(sources, ["GRAPHQL_URL_OVERRIDE", "REACT_APP_AWS_API_ENDPOINT"]) || "https://interface.gateway.uniswap.org/v1/graphql";
-    env.API_BASE_URL_OVERRIDE = "https://interface.gateway.uniswap.org";
-    env.API_BASE_URL_V2_OVERRIDE = "https://interface.gateway.uniswap.org/v2";
-    env.GRAPHQL_URL_OVERRIDE = publicGraphqlUrl;
-    env.TRADING_API_URL_OVERRIDE = "https://trading-api-labs.interface.gateway.uniswap.org";
-    env.FOR_API_URL_OVERRIDE = "https://for.interface.gateway.uniswap.org/v2/FOR.v1.FORService";
-  }
-  return env;
-}
-function ensureUniswapDemoEnvLocal() {
-  const existingSource = (0, import_node_fs.existsSync)(UNISWAP_ENV_LOCAL_FILE) ? (0, import_node_fs.readFileSync)(UNISWAP_ENV_LOCAL_FILE, "utf8") : "";
-  if (existingSource && !existingSource.includes(UNISWAP_DEMO_ENV_MARKER)) {
-    return;
-  }
-  const env = resolveUniswapDemoEnv();
-  const lines = [UNISWAP_DEMO_ENV_MARKER];
-  for (const [key, value] of Object.entries(env).sort(([a], [b]) => a.localeCompare(b))) {
-    lines.push(`${key}=${JSON.stringify(value)}`);
-  }
-  lines.push("");
-  (0, import_node_fs.writeFileSync)(UNISWAP_ENV_LOCAL_FILE, `${lines.join("\n")}
-`);
-}
-function ensureUniswapForceUpgradePatched() {
-  const hookNeedle = `export function useForceUpgradeStatus(): ForceUpgradeStatus {
-`;
-  const hookPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
-  return 'not-required'
-
-`;
-  const hookLegacyPatch = `  // sootsim demo: bypass the force-upgrade gate during local engine demos.
-  if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
-    return 'not-required'
-  }
-
-`;
-  const notificationNeedle = `  const getForceUpgradeStatus = (): ForceUpgradeStatus => {
-`;
-  const notificationPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
-    return 'not-required'
-
-`;
-  const notificationLegacyPatch = `    // sootsim demo: bypass the force-upgrade gate during local engine demos.
-    if (process.env.${UNISWAP_FORCE_UPGRADE_PATCH_MARKER} === 'true') {
-      return 'not-required'
-    }
-
-`;
-  const patchWithMigration = (filePath, needle, patch, legacyPatch) => {
-    const source = (0, import_node_fs.readFileSync)(filePath, "utf8");
-    if (source.includes(patch)) return;
-    if (source.includes(legacyPatch)) {
-      (0, import_node_fs.writeFileSync)(filePath, source.replace(legacyPatch, patch));
-      return;
-    }
-    if (!source.includes(needle)) {
-      throw new Error(
-        `uniswap demo patch failed: expected snippet not found in ${filePath}`
-      );
-    }
-    (0, import_node_fs.writeFileSync)(filePath, source.replace(needle, `${needle}${patch}`));
-  };
-  patchWithMigration(
-    UNISWAP_FORCE_UPGRADE_HOOK_FILE,
-    hookNeedle,
-    hookPatch,
-    hookLegacyPatch
-  );
-  patchWithMigration(
-    UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE,
-    notificationNeedle,
-    notificationPatch,
-    notificationLegacyPatch
-  );
-}
-function ensureJoplinWatchmanConfigs() {
-  if (!(0, import_node_fs.existsSync)(JOPLIN_DIR)) return;
-  for (const rel of JOPLIN_WATCH_ROOTS) {
-    const dir = (0, import_node_path.join)(JOPLIN_DIR, rel);
-    if (!(0, import_node_fs.existsSync)(dir)) continue;
-    const cfg = (0, import_node_path.join)(dir, ".watchmanconfig");
-    if (!(0, import_node_fs.existsSync)(cfg)) (0, import_node_fs.writeFileSync)(cfg, "{}\n");
-  }
-}
-function ensureJoplinBuilt() {
-  if (!(0, import_node_fs.existsSync)(JOPLIN_DIR)) return;
-  const missing = JOPLIN_BUILD_SENTINELS.filter(
-    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(JOPLIN_DIR, rel))
-  );
-  if (missing.length === 0) return;
-  const { execSync } = require("node:child_process");
-  execSync("yarn buildParallel", {
-    cwd: JOPLIN_DIR,
-    stdio: "inherit",
-    env: { ...process.env, NO_FLIPPER: "1", CI: "" }
-  });
-  const stillMissing = JOPLIN_BUILD_SENTINELS.filter(
-    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(JOPLIN_DIR, rel))
-  );
-  if (stillMissing.length > 0) {
-    throw new Error(
-      `joplin demo: yarn buildParallel did not produce: ${stillMissing.join(", ")}`
-    );
-  }
-}
-function runRainbowSetupCommand(command, cwd) {
-  const { execSync } = require("node:child_process");
-  execSync(command, {
-    cwd,
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      METADATA_BASE_URL: RAINBOW_METADATA_BASE_URL,
-      RAINBOW_RELAY_QUOTE_SIGNER: process.env.RAINBOW_RELAY_QUOTE_SIGNER ?? RAINBOW_DEMO_QUOTE_SIGNER
-    }
-  });
-}
-function ensureRainbowGraphqlConfig() {
-  if (!(0, import_node_fs.existsSync)(RAINBOW_GRAPHQL_DIR)) return;
-  const source = (0, import_node_fs.existsSync)(RAINBOW_GRAPHQL_CONFIG_FILE) ? (0, import_node_fs.readFileSync)(RAINBOW_GRAPHQL_CONFIG_FILE, "utf8") : "";
-  if (source.includes(RAINBOW_PUBLIC_ENS_GRAPHQL_URL) && source.includes(RAINBOW_METADATA_BASE_URL)) {
-    return;
-  }
-  (0, import_node_fs.writeFileSync)(
-    RAINBOW_GRAPHQL_CONFIG_FILE,
-    `exports.config = {
-  ens: {
-    __name: 'ens',
-    document: './queries/ens.graphql',
-    schema: {
-      method: 'POST',
-      url: '${RAINBOW_PUBLIC_ENS_GRAPHQL_URL}',
-    },
-  },
-  metadata: {
-    __name: 'metadata',
-    document: './queries/metadata.graphql',
-    schema: { method: 'GET', url: '${RAINBOW_METADATA_BASE_URL}/v1/graph' },
-  },
-  metadataPOST: {
-    __name: 'metadataPOST',
-    document: './queries/metadata.graphql',
-    schema: { method: 'POST', url: '${RAINBOW_METADATA_BASE_URL}/v1/graph' },
-  },
-  arc: {
-    __name: 'arc',
-    document: './queries/arc.graphql',
-    schema: {
-      method: 'GET',
-      url: 'https://arc-graphql.rainbow.me/graphql',
-      headers: {
-        'x-api-key': 'ARC_GRAPHQL_API_KEY',
-      },
-    },
-  },
-  arcDev: {
-    __name: 'arcDev',
-    document: './queries/arc.graphql',
-    schema: {
-      method: 'GET',
-      url: 'https://arc-graphql.rainbowdotme.workers.dev/graphql',
-      headers: {},
-    },
-  },
-};
-`
-  );
-}
-function resolveRainbowDemoEnv() {
-  const env = {
-    ENABLE_DEV_MODE: "1",
-    IS_TESTING: "false",
-    METADATA_BASE_URL: process.env.RAINBOW_METADATA_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
-    ADDYS_API_KEY: process.env.ADDYS_API_KEY ?? RAINBOW_DEMO_SERVICE_API_KEY,
-    ADDYS_BASE_URL: process.env.ADDYS_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
-    PLATFORM_API_KEY: process.env.PLATFORM_API_KEY ?? RAINBOW_DEMO_SERVICE_API_KEY,
-    PLATFORM_BASE_URL: process.env.PLATFORM_BASE_URL ?? RAINBOW_DEMO_METADATA_BASE_URL,
-    RAINBOW_MASTER_KEY: process.env.RAINBOW_MASTER_KEY ?? RAINBOW_DEMO_MASTER_KEY,
-    RAINBOW_RELAY_QUOTE_SIGNER: process.env.RAINBOW_RELAY_QUOTE_SIGNER ?? RAINBOW_DEMO_QUOTE_SIGNER,
-    RAINBOW_RELAY_URL: process.env.RAINBOW_RELAY_URL ?? RAINBOW_DEMO_RELAY_URL,
-    RPC_PROXY_API_KEY_PROD: RAINBOW_DEMO_RPC_API_KEY,
-    RPC_PROXY_BASE_URL_PROD: process.env.RAINBOW_RPC_PROXY_BASE_URL ?? process.env.RPC_PROXY_BASE_URL_PROD ?? RAINBOW_DEMO_RPC_PROXY_BASE_URL,
-    SECURE_WALLET_HASH_KEY: process.env.SECURE_WALLET_HASH_KEY ?? RAINBOW_DEMO_SECURE_WALLET_HASH_KEY,
-    WC_PROJECT_ID: process.env.WC_PROJECT_ID ?? process.env.RAINBOW_WALLETCONNECT_PROJECT_ID ?? RAINBOW_DEMO_WALLETCONNECT_PROJECT_ID
-  };
-  const optionalEnvVars = [
-    "ADDYS_API_KEY",
-    "ADDYS_BASE_URL",
-    "IMGIX_DOMAIN",
-    "IMGIX_TOKEN",
-    "PLATFORM_API_KEY",
-    "PLATFORM_BASE_URL",
-    "RAINBOW_TEST_WALLET",
-    "RAINBOW_RELAY_API_KEY",
-    "RAINBOW_RELAY_URL",
-    "SECURE_WALLET_HASH_KEY",
-    "TOKEN_SEARCH_URL"
-  ];
-  for (const key of optionalEnvVars) {
-    const value = process.env[key];
-    if (value) env[key] = value;
-  }
-  return env;
-}
-function ensureRainbowDemoNetworks() {
-  if (!(0, import_node_fs.existsSync)(RAINBOW_NETWORKS_FILE)) return;
-  const payload = JSON.parse((0, import_node_fs.readFileSync)(RAINBOW_NETWORKS_FILE, "utf8"));
-  if (!Array.isArray(payload.networks)) return;
-  let changed = false;
-  for (const network of payload.networks) {
-    const url = network.id ? RAINBOW_DEMO_PUBLIC_RPC_URLS[network.id] : void 0;
-    if (!url || !network.defaultRPC) continue;
-    if (network.defaultRPC.url === url) continue;
-    network.defaultRPC.url = url;
-    changed = true;
-  }
-  if (changed) {
-    (0, import_node_fs.writeFileSync)(RAINBOW_NETWORKS_FILE, `${JSON.stringify(payload)}
-`);
-  }
-}
-function ensureRainbowSetup() {
-  if (!(0, import_node_fs.existsSync)(RAINBOW_DIR)) return;
-  ensureRainbowGraphqlConfig();
-  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(RAINBOW_GRAPHQL_DIR, "node_modules/.bin/graphql-codegen"))) {
-    runRainbowSetupCommand("fnm exec --using=22 yarn install", RAINBOW_GRAPHQL_DIR);
-  }
-  const missingGraphql = RAINBOW_GRAPHQL_SENTINELS.some(
-    (rel) => !(0, import_node_fs.existsSync)((0, import_node_path.join)(RAINBOW_DIR, rel))
-  );
-  if (missingGraphql) {
-    runRainbowSetupCommand("fnm exec --using=22 yarn codegen", RAINBOW_GRAPHQL_DIR);
-  }
-  if (!(0, import_node_fs.existsSync)(RAINBOW_NETWORKS_FILE)) {
-    runRainbowSetupCommand("fnm exec --using=22 yarn fetch:networks", RAINBOW_DIR);
-  }
-  ensureRainbowDemoNetworks();
-}
-function readArtsyKeysPayload() {
-  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE)) return void 0;
+async function loadOptionalDemoApps() {
+  if (cached) return cached;
   try {
-    const parsed = JSON.parse((0, import_node_fs.readFileSync)(ARTSY_KEYS_FILE, "utf8"));
-    if (!parsed || typeof parsed !== "object") return void 0;
-    const secure = parsed.secure && typeof parsed.secure === "object" ? parsed.secure : void 0;
-    const publicKeys = parsed.public && typeof parsed.public === "object" ? parsed.public : void 0;
-    if (!secure && !publicKeys) return void 0;
-    return { secure, public: publicKeys };
+    const mod = await import(
+      /* @vite-ignore */
+      REGISTRY_SPECIFIER
+    );
+    cached = Array.isArray(mod.APPS) ? mod.APPS : [];
   } catch {
-    return void 0;
-  }
-}
-function resolveArtsyRuntimeConfig() {
-  const email = process.env.SOOTSIM_ARTSY_EMAIL ?? process.env.MAESTRO_TEST_EMAIL;
-  const password = process.env.SOOTSIM_ARTSY_PASSWORD ?? process.env.MAESTRO_TEST_PASSWORD;
-  const keys = readArtsyKeysPayload();
-  const env = {};
-  if (email && password) {
-    env.SOOTSIM_LAUNCH_ARGUMENTS = JSON.stringify({
-      email,
-      password,
-      useMaestroInit: true
-    });
-  }
-  if (keys) {
-    env.SOOTSIM_REACT_NATIVE_KEYS_JSON = JSON.stringify(keys);
+    cached = [];
   }
-  if (Object.keys(env).length === 0) return void 0;
-  return {
-    env
-  };
+  return cached;
 }
-function ensureArtsySetup() {
-  if (!(0, import_node_fs.existsSync)(ARTSY_DIR)) return;
-  const { execSync } = require("node:child_process");
-  const yarnRelease = (0, import_node_path.join)(ARTSY_DIR, ".yarn/releases/yarn-4.10.3.cjs");
-  if ((0, import_node_fs.existsSync)(yarnRelease)) {
-    const src = (0, import_node_fs.readFileSync)(yarnRelease, "utf8");
-    const needle = '["clone","-c core.autocrlf=false",';
-    if (src.includes(needle)) {
-      (0, import_node_fs.writeFileSync)(
-        yarnRelease,
-        src.replace(needle, '["clone","-c","core.autocrlf=false",')
-      );
-    }
-  }
-  if (!(0, import_node_fs.existsSync)((0, import_node_path.join)(ARTSY_DIR, "node_modules/.yarn-state.yml"))) {
-    execSync("yarn install", {
-      cwd: ARTSY_DIR,
-      stdio: "inherit",
-      env: { ...process.env, YARN_CHECKSUM_BEHAVIOR: "update" }
-    });
-  }
-  if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
-    try {
-      execSync("yarn setup:oss", { cwd: ARTSY_DIR, stdio: "inherit" });
-    } catch {
-      if (!(0, import_node_fs.existsSync)(ARTSY_KEYS_FILE) || !(0, import_node_fs.existsSync)(ARTSY_METAFLAGS_FILE)) {
-        throw new Error("artsy demo: setup:oss did not create keys/metaflags");
-      }
-    }
-  }
-  const rnlaPkgJson = (0, import_node_path.join)(
-    ARTSY_DIR,
-    "node_modules/react-native-launch-arguments/package.json"
-  );
-  if ((0, import_node_fs.existsSync)(rnlaPkgJson)) {
-    const raw = (0, import_node_fs.readFileSync)(rnlaPkgJson, "utf8");
-    if (raw.includes('"dist/index.js"')) {
-      (0, import_node_fs.writeFileSync)(rnlaPkgJson, raw.replace('"dist/index.js"', '"src/index.ts"'));
-    }
-  }
-  if (!(0, import_node_fs.existsSync)(ARTSY_RELAY_SENTINEL)) {
-    execSync("yarn relay", { cwd: ARTSY_DIR, stdio: "inherit" });
-    (0, import_node_fs.writeFileSync)(ARTSY_RELAY_SENTINEL, "");
-  }
+function optionalDemoAppsSync() {
+  return cached ?? [];
 }
-var import_node_fs, import_node_os, import_node_path, HOME, getExpensifyProxyScript, getRainbowMetadataProxyScript, getMattermostRNUtilsNativeModule, getMattermostKeychainNativeModule, getMattermostNetworkClientNativeModule, getMattermostPreviewServerScript, EXPENSIFY_NATIVE_PROXY_ENV, MATTERMOST_DIR, UNISWAP_REPO_DIR, UNISWAP_APP_DIR, UNISWAP_ENV_LOCAL_FILE, UNISWAP_PLACEHOLDER, UNISWAP_DEMO_ENV_MARKER, UNISWAP_FORCE_UPGRADE_HOOK_FILE, UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE, UNISWAP_FORCE_UPGRADE_PATCH_MARKER, JOPLIN_DIR, JOPLIN_APP_DIR, JOPLIN_WATCH_ROOTS, JOPLIN_BUILD_SENTINELS, RAINBOW_DIR, RAINBOW_GRAPHQL_DIR, RAINBOW_GRAPHQL_CONFIG_FILE, RAINBOW_NETWORKS_FILE, RAINBOW_METADATA_BASE_URL, RAINBOW_METADATA_PROXY_PORT, RAINBOW_DEMO_METADATA_BASE_URL, RAINBOW_PUBLIC_ENS_GRAPHQL_URL, RAINBOW_DEMO_QUOTE_SIGNER, RAINBOW_DEMO_RELAY_URL, RAINBOW_DEMO_MASTER_KEY, RAINBOW_DEMO_RPC_PROXY_BASE_URL, RAINBOW_DEMO_RPC_API_KEY, RAINBOW_DEMO_PUBLIC_RPC_URLS, RAINBOW_DEMO_SERVICE_API_KEY, RAINBOW_DEMO_SECURE_WALLET_HASH_KEY, RAINBOW_DEMO_WALLETCONNECT_PROJECT_ID, RAINBOW_GRAPHQL_SENTINELS, ARTSY_DIR, ARTSY_KEYS_FILE, ARTSY_METAFLAGS_FILE, ARTSY_RELAY_SENTINEL, APPS;
-var init_demo_app_registry = __esm({
-  "scripts/demo-app-registry.ts"() {
+var REGISTRY_SPECIFIER, cached;
+var init_optional_demo_registry = __esm({
+  "scripts/optional-demo-registry.ts"() {
     "use strict";
-    import_node_fs = require("node:fs");
-    import_node_os = require("node:os");
-    import_node_path = require("node:path");
-    HOME = (0, import_node_os.homedir)();
-    getExpensifyProxyScript = () => resolveWorkspaceScriptPath(
-      "packages/sootsim-engine/scripts/expensify-web-proxy.ts",
-      "scripts/expensify-web-proxy.ts"
-    );
-    getRainbowMetadataProxyScript = () => resolveWorkspaceScriptPath(
-      "packages/sootsim-engine/scripts/rainbow-metadata-proxy.ts",
-      "scripts/rainbow-metadata-proxy.ts"
-    );
-    getMattermostRNUtilsNativeModule = () => resolveWorkspaceScriptPath(
-      "packages/compat/src/stubs/mattermost-rnutils-native.ts",
-      "../compat/src/stubs/mattermost-rnutils-native.ts"
-    );
-    getMattermostKeychainNativeModule = () => resolveWorkspaceScriptPath(
-      "packages/compat/src/stubs/native-seams/react-native-keychain-manager.ts",
-      "../compat/src/stubs/native-seams/react-native-keychain-manager.ts"
-    );
-    getMattermostNetworkClientNativeModule = () => resolveWorkspaceScriptPath(
-      "packages/compat/src/stubs/mattermost-network-client-native.ts",
-      "../compat/src/stubs/mattermost-network-client-native.ts"
-    );
-    getMattermostPreviewServerScript = () => resolveWorkspaceScriptPath(
-      "packages/sootsim-engine/scripts/mattermost-preview-server.ts",
-      "scripts/mattermost-preview-server.ts"
-    );
-    EXPENSIFY_NATIVE_PROXY_ENV = {
-      USE_NGROK: "true",
-      NGROK_URL: "http://localhost:9000/",
-      SECURE_NGROK_URL: "http://localhost:9000/"
-    };
-    MATTERMOST_DIR = (0, import_node_path.join)(HOME, "github/mattermost-mobile");
-    UNISWAP_REPO_DIR = (0, import_node_path.join)(HOME, "github/uniswap-interface");
-    UNISWAP_APP_DIR = (0, import_node_path.join)(UNISWAP_REPO_DIR, "apps/mobile");
-    UNISWAP_ENV_LOCAL_FILE = (0, import_node_path.join)(UNISWAP_REPO_DIR, ".env.defaults.local");
-    UNISWAP_PLACEHOLDER = "stored-in-.env.local";
-    UNISWAP_DEMO_ENV_MARKER = "# sootsim demo env overrides";
-    UNISWAP_FORCE_UPGRADE_HOOK_FILE = (0, import_node_path.join)(
-      UNISWAP_REPO_DIR,
-      "packages/uniswap/src/features/forceUpgrade/hooks/useForceUpgradeStatus.ts"
-    );
-    UNISWAP_FORCE_UPGRADE_NOTIFICATION_FILE = (0, import_node_path.join)(
-      UNISWAP_REPO_DIR,
-      "apps/mobile/src/notification-service/data-sources/createForceUpgradeNotificationDataSource.ts"
-    );
-    UNISWAP_FORCE_UPGRADE_PATCH_MARKER = "SOOTSIM_DEMO_DISABLE_FORCE_UPGRADE";
-    JOPLIN_DIR = (0, import_node_path.join)(HOME, "github/joplin");
-    JOPLIN_APP_DIR = (0, import_node_path.join)(JOPLIN_DIR, "packages/app-mobile");
-    JOPLIN_WATCH_ROOTS = [
-      "packages/lib",
-      "packages/renderer",
-      "packages/turndown",
-      "packages/turndown-plugin-gfm",
-      "packages/editor",
-      "packages/tools",
-      "packages/utils",
-      "packages/fork-htmlparser2",
-      "packages/fork-uslug",
-      "packages/fork-sax",
-      "packages/htmlpack",
-      "packages/react-native-saf-x",
-      "packages/react-native-alarm-notification"
-    ];
-    JOPLIN_BUILD_SENTINELS = [
-      "packages/lib/models/Setting.js",
-      "packages/turndown/lib/turndown.cjs.js",
-      "packages/app-mobile/pluginAssets/index.js"
-    ];
-    RAINBOW_DIR = (0, import_node_path.join)(HOME, "github/rainbow");
-    RAINBOW_GRAPHQL_DIR = (0, import_node_path.join)(RAINBOW_DIR, "src/graphql");
-    RAINBOW_GRAPHQL_CONFIG_FILE = (0, import_node_path.join)(RAINBOW_GRAPHQL_DIR, "config.js");
-    RAINBOW_NETWORKS_FILE = (0, import_node_path.join)(RAINBOW_DIR, "src/references/networks.json");
-    RAINBOW_METADATA_BASE_URL = "https://metadata.p.rainbow.me";
-    RAINBOW_METADATA_PROXY_PORT = 9011;
-    RAINBOW_DEMO_METADATA_BASE_URL = `http://127.0.0.1:${RAINBOW_METADATA_PROXY_PORT}`;
-    RAINBOW_PUBLIC_ENS_GRAPHQL_URL = "https://api.thegraph.com/subgraphs/name/ensdomains/ens";
-    RAINBOW_DEMO_QUOTE_SIGNER = "0x0000000000000000000000000000000000000000";
-    RAINBOW_DEMO_RELAY_URL = "https://relay.rainbow.me";
-    RAINBOW_DEMO_MASTER_KEY = "sootsim-rainbow-demo-master-key-do-not-use-for-real-wallets";
-    RAINBOW_DEMO_RPC_PROXY_BASE_URL = "https://rpc.rainbow.me/v1";
-    RAINBOW_DEMO_RPC_API_KEY = "";
-    RAINBOW_DEMO_PUBLIC_RPC_URLS = {
-      "1": "https://ethereum-rpc.publicnode.com"
-    };
-    RAINBOW_DEMO_SERVICE_API_KEY = "sootsim-rainbow-demo-api-key";
-    RAINBOW_DEMO_SECURE_WALLET_HASH_KEY = "0x736f6f7473696d2d7261696e626f772d64656d6f2d686173682d6b6579000000";
-    RAINBOW_DEMO_WALLETCONNECT_PROJECT_ID = "00000000000000000000000000000000";
-    RAINBOW_GRAPHQL_SENTINELS = [
-      "src/graphql/__generated__/ens.ts",
-      "src/graphql/__generated__/metadata.ts",
-      "src/graphql/__generated__/metadataPOST.ts"
-    ];
-    ARTSY_DIR = (0, import_node_path.join)(HOME, "github/eigen");
-    ARTSY_KEYS_FILE = (0, import_node_path.join)(ARTSY_DIR, "keys.shared.json");
-    ARTSY_METAFLAGS_FILE = (0, import_node_path.join)(ARTSY_DIR, "metaflags.json");
-    ARTSY_RELAY_SENTINEL = (0, import_node_path.join)(ARTSY_DIR, "src/__generated__/.relay-complete");
-    APPS = [
-      {
-        name: "bluesky",
-        label: "Bluesky",
-        dir: (0, import_node_path.join)(HOME, "github/bluesky"),
-        preferredPort: 8082,
-        framework: "expo",
-        command: (p) => ({ cmd: `npx expo start --port ${p}` }),
-        credentials: {
-          envVars: ["SOOTSIM_BLUESKY_PASSWORD"],
-          known: { HANDLE: "natew.bsky.social" }
-        }
-      },
-      {
-        name: "3pc",
-        label: "3PunchConvo",
-        dir: (0, import_node_path.join)(HOME, "lightstrike-labs/three-punch-convo-app/apps/one"),
-        preferredPort: 8081,
-        framework: "one",
-        command: (p) => ({ cmd: "npx one dev", env: { ONE_PORT: String(p) } })
-      },
-      {
-        name: "uniswap",
-        label: "Uniswap",
-        dir: UNISWAP_APP_DIR,
-        preferredPort: 8085,
-        framework: "expo",
-        prepare: () => {
-          ensureUniswapDemoEnvLocal();
-          ensureUniswapForceUpgradePatched();
-        },
-        command: (p) => ({
-          cmd: `npx expo start --clear --port ${p}`,
-          // prefer the real local mobile env when present, otherwise fall back
-          // to Uniswap's checked-in public web RPC settings so demo boots cleanly.
-          env: resolveUniswapDemoEnv()
-        })
-      },
-      {
-        name: "takeout",
-        label: "Takeout",
-        dir: (0, import_node_path.join)(HOME, "takeout"),
-        preferredPort: 8086,
-        framework: "one",
-        // takeout needs more than Metro for the demo to actually work: better-auth
-        // (login), zero-cache (sync), and a postgres for both. `bun lite` brings
-        // up the orez-backed stack (PG + zero + s3 in one binary) plus the One
-        // dev server. takeout's env system shifts every port (web, pg, zero,
-        // minio) uniformly by PORT_OFFSET, so we derive offset = port - 8081
-        // (the base web port) to keep all backend ports clear of the default
-        // dev stack while pinning One to the demo slot. OREZ_DATA_DIR is isolated
-        // to a per-demo path so we don't fight a soot dev orez that may already
-        // be holding pglite locks on ~/takeout/.orez (soot can attach takeout as
-        // a project and spin up its own orez against the same data dir).
-        readyTimeoutMs: 24e4,
-        managedPorts: (p) => {
-          const offset = p - 8081;
-          return [5433 + offset, 4848 + offset, 9200 + offset];
-        },
-        command: (p) => ({
-          cmd: "bun lite:demo",
-          env: {
-            TAKEOUT_ENV_MODE: "development",
-            PORT_OFFSET: String(p - 8081),
-            OREZ_DATA_DIR: `${HOME}/.cache/sootsim-demo/takeout-orez`,
-            VITE_DEMO_MODE: "1",
-            ZERO_APP_ID: "takeout",
-            ZERO_APP_PUBLICATIONS: "zero_takeout",
-            ZERO_CVR_MAX_CONNS: "4",
-            ZERO_NUM_SYNC_WORKERS: "2",
-            ZERO_UPSTREAM_MAX_CONNS: "8"
-          }
-        })
-      },
-      {
-        name: "expensify",
-        label: "Expensify",
-        dir: (0, import_node_path.join)(HOME, "github/expensify"),
-        preferredPort: 8087,
-        framework: "rock",
-        runtimeConfig: {
-          env: EXPENSIFY_NATIVE_PROXY_ENV
-        },
-        sidecars: [
-          {
-            name: "web-proxy",
-            port: 9e3,
-            readyPath: "/api/Ping",
-            command: () => ({
-              cmd: `bun ${JSON.stringify(getExpensifyProxyScript())}`,
-              env: EXPENSIFY_NATIVE_PROXY_ENV
-            })
-          }
-        ],
-        command: (p) => ({
-          cmd: `fnm exec --using=20.20.0 npx rock start --port ${p} --no-interactive`,
-          env: EXPENSIFY_NATIVE_PROXY_ENV
-        })
-      },
-      {
-        name: "artsy",
-        label: "Artsy",
-        dir: ARTSY_DIR,
-        preferredPort: 8088,
-        framework: "expo",
-        runtimeConfig: resolveArtsyRuntimeConfig(),
-        prepare: () => {
-          ensureArtsySetup();
-        },
-        command: (p) => ({
-          // eigen's `yarn start` wraps `react-native start` with a relay watcher
-          // via concurrently; for the demo we run relay once in prepare and
-          // invoke the metro server directly so --port is respected.
-          cmd: `npx react-native start --port ${p}`
-        }),
-        credentials: {
-          envVars: ["SOOTSIM_ARTSY_EMAIL", "SOOTSIM_ARTSY_PASSWORD"],
-          note: "auto-login reuses Artsy\u2019s built-in Maestro launch-arguments hook"
-        }
-      },
-      {
-        name: "rainbow",
-        label: "Rainbow",
-        dir: RAINBOW_DIR,
-        preferredPort: 8089,
-        framework: "rock",
-        sidecars: [
-          {
-            name: "metadata-proxy",
-            port: RAINBOW_METADATA_PROXY_PORT,
-            readyPath: "/health",
-            command: () => ({
-              cmd: `bun ${JSON.stringify(getRainbowMetadataProxyScript())}`,
-              env: {
-                PORT: String(RAINBOW_METADATA_PROXY_PORT),
-                RAINBOW_PUBLIC_RPC_URLS: JSON.stringify(RAINBOW_DEMO_PUBLIC_RPC_URLS),
-                RAINBOW_UPSTREAM_METADATA_BASE_URL: RAINBOW_METADATA_BASE_URL
-              }
-            })
-          }
-        ],
-        prepare: () => {
-          ensureRainbowSetup();
-        },
-        command: (p) => ({
-          cmd: `fnm exec --using=22 yarn start --port ${p} --reset-cache`,
-          env: resolveRainbowDemoEnv()
-        }),
-        credentials: {
-          envVars: ["RAINBOW_TEST_WALLET"],
-          optionalEnvVars: [
-            "RAINBOW_WALLETCONNECT_PROJECT_ID",
-            "WC_PROJECT_ID",
-            "IMGIX_DOMAIN",
-            "IMGIX_TOKEN"
-          ],
-          note: "launcher supplies demo encryption, public mainnet RPC, and a placeholder WalletConnect project id; use only a public throwaway mnemonic for RAINBOW_TEST_WALLET"
-        }
-      },
-      {
-        name: "rocket-chat",
-        label: "Rocket.Chat",
-        dir: (0, import_node_path.join)(HOME, "github/Rocket.Chat.ReactNative"),
-        preferredPort: 8093,
-        framework: "expo",
-        command: (p) => ({
-          cmd: `npx react-native start --port ${p}`,
-          env: { RUNNING_E2E_TESTS: "true" }
-        }),
-        credentials: {
-          envVars: [
-            "ROCKET_CHAT_DEMO_SERVER",
-            "ROCKET_CHAT_DEMO_USERNAME",
-            "ROCKET_CHAT_DEMO_PASSWORD"
-          ],
-          known: { SERVER: "https://mobile.qa.rocket.chat" },
-          note: "use packages/sootsim-engine/scripts/rocket-chat-demo-auth.ts to create/login a disposable QA user and print the rocketchat://auth deep link"
-        }
-      },
-      {
-        name: "mattermost",
-        label: "Mattermost",
-        dir: MATTERMOST_DIR,
-        preferredPort: 8090,
-        framework: "expo",
-        sidecars: [
-          {
-            name: "preview-server",
-            port: 8065,
-            readyPath: "/api/v4/system/ping",
-            command: () => ({
-              cmd: `bun ${JSON.stringify(getMattermostPreviewServerScript())}`
-            })
-          }
-        ],
-        runtimeConfig: {
-          modules: {
-            // mattermost patches react-native-keychain's JS entry in its own
-            // repo; run that package and provide only the native manager seam.
-            "react-native-keychain": false,
-            "dist/assets/config.json": {
-              inline: {
-                AuthUrlScheme: "mmauth://",
-                AuthUrlSchemeDev: "mmauthbeta://",
-                DefaultServerUrl: "http://localhost:8065",
-                DefaultServerName: "Mattermost Demo",
-                TestServerUrl: "http://localhost:8065",
-                AutoSelectServerUrl: true,
-                WebsiteURL: "https://mattermost.com",
-                ServerNoticeURL: "https://github.com/mattermost/mattermost-server/blob/master/NOTICE.txt",
-                MobileNoticeURL: "https://github.com/mattermost/mattermost-mobile/blob/master/NOTICE.txt",
-                RudderApiKey: "",
-                SentryEnabled: false,
-                SentryDsnIos: "",
-                SentryDsnAndroid: "",
-                SentryOptions: {
-                  deactivateStacktraceMerging: true,
-                  autoBreadcrumbs: {
-                    xhr: false,
-                    console: true
-                  },
-                  severityLevelFilter: ["fatal"]
-                },
-                ShowReview: false,
-                ShowOnboarding: false,
-                ExperimentalNormalizeMarkdownLinks: false,
-                CustomRequestHeaders: {},
-                CollectNetworkMetrics: false
-              }
-            }
-          },
-          nativeModules: {
-            RNKeychainManager: { file: getMattermostKeychainNativeModule() },
-            RNUtils: { file: getMattermostRNUtilsNativeModule() },
-            GenericClient: { file: getMattermostNetworkClientNativeModule() },
-            ApiClient: { file: getMattermostNetworkClientNativeModule() },
-            WebSocketClient: { file: getMattermostNetworkClientNativeModule() }
-          }
-        },
-        command: (p) => ({
-          cmd: `npx react-native start --host 127.0.0.1 --port ${p}`
-        }),
-        credentials: {
-          known: {
-            SERVER: "http://localhost:8065",
-            USERNAME: "demo",
-            PASSWORD: "DemoPassword1!"
-          },
-          note: "local mattermost-preview seeded through the real REST API; no signup or OTP needed"
-        }
-      },
-      {
-        name: "joplin",
-        label: "Joplin",
-        dir: JOPLIN_APP_DIR,
-        preferredPort: 8084,
-        framework: "expo",
-        // joplin is local-first: sync.target defaults to 0 ("None") and the
-        // mobile startup runs WelcomeUtils.install() on first launch, which
-        // seeds a "Welcome!" folder + welcome notes. no login or external
-        // credentials are needed for a usable demo — just boot it. tenant
-        // bedrock SQLite (via react-native-sqlite-storage stub) carries the
-        // seeded notes across reloads.
-        prepare: () => {
-          ensureJoplinWatchmanConfigs();
-          ensureJoplinBuilt();
-        },
-        command: (p) => ({
-          cmd: `npx expo start --port ${p}`,
-          env: { BROWSERSLIST_IGNORE_OLD_DATA: "true" }
-        }),
-        credentials: {
-          note: "no login required \u2014 sync.target=0 (None), seed via WelcomeUtils"
-        }
-      }
-    ];
+    REGISTRY_SPECIFIER = "./demo-app-registry.ts";
+    cached = null;
   }
 });
 
 // scripts/dev-server-scanner.ts
 function tcpPing(port, timeout = TCP_GATE_MS) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve6) => {
     const sock = new import_net.default.Socket();
     let settled = false;
     const done = (ok) => {
       if (settled) return;
       settled = true;
       sock.destroy();
-      resolve7(ok);
+      resolve6(ok);
     };
     sock.setTimeout(timeout);
     sock.once("connect", () => done(true));
@@ -10450,7 +10084,7 @@ function tcpPing(port, timeout = TCP_GATE_MS) {
   });
 }
 function httpGet(port, path9, method = "GET", timeout = TIMEOUT_MS, headers = {}) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve6) => {
     const req = import_http.default.request(
       { hostname: "localhost", port, path: path9, method, timeout, headers },
       (res) => {
@@ -10464,14 +10098,14 @@ function httpGet(port, path9, method = "GET", timeout = TIMEOUT_MS, headers = {}
         })();
         res.on(
           "end",
-          () => resolve7({ statusCode: res.statusCode || 0, body, contentType })
+          () => resolve6({ statusCode: res.statusCode || 0, body, contentType })
         );
       }
     );
-    req.on("error", () => resolve7(null));
+    req.on("error", () => resolve6(null));
     req.setTimeout(timeout, () => {
       req.destroy();
-      resolve7(null);
+      resolve6(null);
     });
     req.end();
   });
@@ -10534,8 +10168,8 @@ async function discoverListeningProcesses(excludePorts = []) {
 }
 async function resolveProcessCwd(pid) {
   if (pid <= 0) return null;
-  const cached3 = cwdByPid.get(pid);
-  if (cached3) return cached3;
+  const cached4 = cwdByPid.get(pid);
+  if (cached4) return cached4;
   try {
     const { stdout } = await execP(`lsof -p ${pid} -a -d cwd -Fn 2>/dev/null`, {
       encoding: "utf8",
@@ -10567,7 +10201,7 @@ function makeResult(port, framework) {
   };
 }
 function withRuntimeConfig(port, bundleUrl) {
-  const knownApp = APPS.find((app) => app.preferredPort === port);
+  const knownApp = optionalDemoAppsSync().find((app) => app.preferredPort === port);
   const configured = knownApp?.runtimeConfig ? applySootSimConfigToUrl(bundleUrl, knownApp.runtimeConfig) : bundleUrl;
   return normalizeNativeDevBundleUrl(configured);
 }
@@ -10737,12 +10371,12 @@ async function scanDevServers(opts = {}) {
   const results = [];
   const toProbe = [];
   for (const { port, pid } of processes) {
-    const cached3 = portCache.get(port);
-    if (cached3 && __shouldReuseScannerCacheEntry(cached3, pid)) {
-      if (cached3.result) results.push(cached3.result);
+    const cached4 = portCache.get(port);
+    if (cached4 && __shouldReuseScannerCacheEntry(cached4, pid)) {
+      if (cached4.result) results.push(cached4.result);
       continue;
     }
-    if (cached3 && cached3.pid !== pid) {
+    if (cached4 && cached4.pid !== pid) {
       knownNonPatched.delete(port);
       knownNonExpo.delete(port);
       knownOne.delete(port);
@@ -10788,8 +10422,9 @@ var init_dev_server_scanner = __esm({
     import_util = require("util");
     init_config();
     init_native_dev_bundle_url();
-    init_demo_app_registry();
+    init_optional_demo_registry();
     execP = (0, import_util.promisify)(import_child_process.exec);
+    void loadOptionalDemoApps();
     TIMEOUT_MS = 250;
     MANIFEST_TIMEOUT_MS = 1500;
     TCP_GATE_MS = 120;
@@ -10816,71 +10451,71 @@ var init_dev_server_scanner = __esm({
 
 // src/cli-version.ts
 function getCliVersion() {
-  if (cached != null) return cached;
+  if (cached2 != null) return cached2;
   const candidates = [
     () => (0, import_node_url.fileURLToPath)(import_meta.resolve("sootsim/package.json")),
     () => (0, import_node_url.fileURLToPath)(new URL("../package.json", __sootsim_import_meta_url))
   ];
-  for (const resolve7 of candidates) {
+  for (const resolve6 of candidates) {
     try {
-      const version = JSON.parse((0, import_node_fs2.readFileSync)(resolve7(), "utf8")).version;
+      const version = JSON.parse((0, import_node_fs.readFileSync)(resolve6(), "utf8")).version;
       if (typeof version === "string" && version) {
-        cached = version;
-        return cached;
+        cached2 = version;
+        return cached2;
       }
     } catch {
     }
   }
-  cached = "0.0.0";
-  return cached;
+  cached2 = "0.0.0";
+  return cached2;
 }
-var import_node_fs2, import_node_url, import_meta, cached;
+var import_node_fs, import_node_url, import_meta, cached2;
 var init_cli_version = __esm({
   "src/cli-version.ts"() {
     "use strict";
-    import_node_fs2 = require("node:fs");
+    import_node_fs = require("node:fs");
     import_node_url = require("node:url");
     import_meta = {};
-    cached = null;
+    cached2 = null;
   }
 });
 
 // src/home-paths.ts
 function sootsimHomeDir() {
   const override = process.env[SOOTSIM_HOME_ENV];
-  if (override && override.length > 0) return import_node_path2.default.resolve(override);
-  return import_node_path2.default.join((0, import_node_os2.homedir)(), ".sootsim");
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".sootsim");
 }
 function runtimesDir() {
-  return import_node_path2.default.join(sootsimHomeDir(), "runtimes");
+  return import_node_path.default.join(sootsimHomeDir(), "runtimes");
 }
 function runtimeDir(version) {
-  return import_node_path2.default.join(runtimesDir(), version);
+  return import_node_path.default.join(runtimesDir(), version);
 }
 function activeRuntimeFile() {
-  return import_node_path2.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
+  return import_node_path.default.join(runtimesDir(), ACTIVE_RUNTIME_FILE);
 }
 function electronDir() {
-  return import_node_path2.default.join(sootsimHomeDir(), "electron");
+  return import_node_path.default.join(sootsimHomeDir(), "electron");
 }
 function electronUserDataDir() {
-  return import_node_path2.default.join(electronDir(), "userData");
+  return import_node_path.default.join(electronDir(), "userData");
 }
 function profilesDir() {
-  return import_node_path2.default.join(sootsimHomeDir(), "profiles");
+  return import_node_path.default.join(sootsimHomeDir(), "profiles");
 }
 function cacheDir() {
-  return import_node_path2.default.join(sootsimHomeDir(), "cache");
+  return import_node_path.default.join(sootsimHomeDir(), "cache");
 }
 function daemonLockfilePath() {
-  return import_node_path2.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
+  return import_node_path.default.join(sootsimHomeDir(), DAEMON_LOCKFILE);
 }
 function configFilePath() {
-  return import_node_path2.default.join(sootsimHomeDir(), CONFIG_FILE);
+  return import_node_path.default.join(sootsimHomeDir(), CONFIG_FILE);
 }
 function readSharedConfig() {
   try {
-    const raw = import_node_fs3.default.readFileSync(configFilePath(), "utf8");
+    const raw = import_node_fs2.default.readFileSync(configFilePath(), "utf8");
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
@@ -10898,34 +10533,34 @@ function writeSharedConfig(patch) {
     };
   }
   const tmp = `${configFilePath()}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
+  import_node_fs2.default.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, configFilePath());
+  import_node_fs2.default.renameSync(tmp, configFilePath());
   return next;
 }
 function ensureSootsimHome() {
-  import_node_fs3.default.mkdirSync(sootsimHomeDir(), { 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 });
+  import_node_fs2.default.mkdirSync(sootsimHomeDir(), { recursive: true });
+  import_node_fs2.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs2.default.mkdirSync(electronDir(), { recursive: true });
+  import_node_fs2.default.mkdirSync(profilesDir(), { recursive: true });
+  import_node_fs2.default.mkdirSync(cacheDir(), { recursive: true });
 }
 function readActiveRuntime() {
   try {
-    const value = import_node_fs3.default.readFileSync(activeRuntimeFile(), "utf8").trim();
+    const value = import_node_fs2.default.readFileSync(activeRuntimeFile(), "utf8").trim();
     return value.length > 0 ? value : null;
   } catch {
     return null;
   }
 }
 function writeActiveRuntime(version) {
-  import_node_fs3.default.mkdirSync(runtimesDir(), { recursive: true });
-  import_node_fs3.default.writeFileSync(activeRuntimeFile(), `${version}
+  import_node_fs2.default.mkdirSync(runtimesDir(), { recursive: true });
+  import_node_fs2.default.writeFileSync(activeRuntimeFile(), `${version}
 `, "utf8");
 }
 function listInstalledRuntimes() {
   try {
-    return import_node_fs3.default.readdirSync(runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
+    return import_node_fs2.default.readdirSync(runtimesDir(), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort(compareSemver);
   } catch {
     return [];
   }
@@ -10956,17 +10591,17 @@ function activeRuntimeDir() {
   if (!version) return null;
   const dir = runtimeDir(version);
   try {
-    if (import_node_fs3.default.statSync(dir).isDirectory()) return dir;
+    if (import_node_fs2.default.statSync(dir).isDirectory()) return dir;
   } catch {
   }
   return null;
 }
 function readDaemonLockfile() {
   try {
-    const fd = import_node_fs3.default.openSync(daemonLockfilePath(), "r");
+    const fd = import_node_fs2.default.openSync(daemonLockfilePath(), "r");
     try {
       const buf = Buffer.alloc(DAEMON_LOCKFILE_MAX_BYTES);
-      const bytesRead = import_node_fs3.default.readSync(fd, buf, 0, DAEMON_LOCKFILE_MAX_BYTES, 0);
+      const bytesRead = import_node_fs2.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") {
@@ -10974,7 +10609,7 @@ function readDaemonLockfile() {
       }
       return null;
     } finally {
-      import_node_fs3.default.closeSync(fd);
+      import_node_fs2.default.closeSync(fd);
     }
   } catch {
     return null;
@@ -10993,9 +10628,9 @@ function isDaemonLockfileFresh(lock, now = Date.now()) {
 function writeDaemonLockfile(data) {
   ensureSootsimHome();
   const tmp = `${daemonLockfilePath()}.tmp`;
-  import_node_fs3.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+  import_node_fs2.default.writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-  import_node_fs3.default.renameSync(tmp, daemonLockfilePath());
+  import_node_fs2.default.renameSync(tmp, daemonLockfilePath());
 }
 function claimDaemonLockfile(data) {
   ensureSootsimHome();
@@ -11008,17 +10643,17 @@ function claimDaemonLockfile(data) {
 }
 function removeDaemonLockfile() {
   try {
-    import_node_fs3.default.unlinkSync(daemonLockfilePath());
+    import_node_fs2.default.unlinkSync(daemonLockfilePath());
   } catch {
   }
 }
-var import_node_fs3, import_node_os2, import_node_path2, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES;
+var import_node_fs2, import_node_os, import_node_path, SOOTSIM_HOME_ENV, ACTIVE_RUNTIME_FILE, DAEMON_LOCKFILE, CONFIG_FILE, DAEMON_HEARTBEAT_STALE_MS, DAEMON_LOCKFILE_MAX_BYTES;
 var init_home_paths = __esm({
   "src/home-paths.ts"() {
     "use strict";
-    import_node_fs3 = __toESM(require("node:fs"), 1);
-    import_node_os2 = require("node:os");
-    import_node_path2 = __toESM(require("node:path"), 1);
+    import_node_fs2 = __toESM(require("node:fs"), 1);
+    import_node_os = require("node:os");
+    import_node_path = __toESM(require("node:path"), 1);
     SOOTSIM_HOME_ENV = "SOOTSIM_HOME";
     ACTIVE_RUNTIME_FILE = "active";
     DAEMON_LOCKFILE = "daemon.json";
@@ -11209,22 +10844,22 @@ async function downloadToFile(url, destPath) {
   }
 }
 function sha256File(filePath) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve6, reject) => {
     const hash = import_crypto.default.createHash("sha256");
     const stream = import_fs.default.createReadStream(filePath);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
-    stream.on("end", () => resolve7(hash.digest("hex")));
+    stream.on("end", () => resolve6(hash.digest("hex")));
   });
 }
 function extractTarball(tarPath, destDir) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = (0, import_child_process2.spawn)("tar", ["-xzf", tarPath, "-C", destDir], {
       stdio: ["ignore", "inherit", "inherit"]
     });
     child.on("error", reject);
     child.on("exit", (code) => {
-      if (code === 0) resolve7();
+      if (code === 0) resolve6();
       else reject(new Error(`tar exited with code ${code}`));
     });
   });
@@ -11307,7 +10942,7 @@ function getUserDataDir() {
   return userDataDir();
 }
 function storeFile() {
-  return import_node_path3.default.join(userDataDir(), "attached-projects.json");
+  return import_node_path2.default.join(userDataDir(), "attached-projects.json");
 }
 function cloneEmpty() {
   return {
@@ -11321,7 +10956,7 @@ function loadStore() {
   const file = storeFile();
   let raw;
   try {
-    raw = import_node_fs4.default.readFileSync(file, "utf8");
+    raw = import_node_fs3.default.readFileSync(file, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return cloneEmpty();
     throw err;
@@ -11338,7 +10973,7 @@ function loadStore() {
   } catch (err) {
     const quarantine = `${file}.corrupt-${Date.now()}`;
     try {
-      import_node_fs4.default.renameSync(file, quarantine);
+      import_node_fs3.default.renameSync(file, quarantine);
       console.warn(
         `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. original error: ${err.message}`
       );
@@ -11349,16 +10984,16 @@ function loadStore() {
 }
 function writeStore(store) {
   const file = storeFile();
-  import_node_fs4.default.mkdirSync(import_node_path3.default.dirname(file), { recursive: true });
+  import_node_fs3.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  const fd = import_node_fs4.default.openSync(tmp, "w", 384);
+  const fd = import_node_fs3.default.openSync(tmp, "w", 384);
   try {
-    import_node_fs4.default.writeFileSync(fd, JSON.stringify(store, null, 2));
-    import_node_fs4.default.fsyncSync(fd);
+    import_node_fs3.default.writeFileSync(fd, JSON.stringify(store, null, 2));
+    import_node_fs3.default.fsyncSync(fd);
   } finally {
-    import_node_fs4.default.closeSync(fd);
+    import_node_fs3.default.closeSync(fd);
   }
-  import_node_fs4.default.renameSync(tmp, file);
+  import_node_fs3.default.renameSync(tmp, file);
 }
 function mutateStore(fn) {
   const store = loadStore();
@@ -11367,13 +11002,13 @@ function mutateStore(fn) {
   return store;
 }
 function projectIdForCwd(cwd) {
-  return (0, import_node_crypto.createHash)("sha256").update(import_node_path3.default.resolve(cwd)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto.createHash)("sha256").update(import_node_path2.default.resolve(cwd)).digest("hex").slice(0, 16);
 }
 function newSessionId() {
   return `s_${(0, import_node_crypto.randomBytes)(10).toString("hex")}`;
 }
 function upsertProject(input) {
-  const cwd = import_node_path3.default.resolve(input.cwd);
+  const cwd = import_node_path2.default.resolve(input.cwd);
   const id = projectIdForCwd(cwd);
   let result;
   mutateStore((store) => {
@@ -11399,7 +11034,7 @@ function upsertProject(input) {
     const now = Date.now();
     const created = {
       id,
-      name: input.name ?? import_node_path3.default.basename(cwd),
+      name: input.name ?? import_node_path2.default.basename(cwd),
       cwd,
       repoRoot: input.repoRoot,
       sourceRoots: input.sourceRoots ?? [cwd],
@@ -11523,23 +11158,13 @@ function updateSessionStatus(id, patch) {
 async function seedFromDemoAppRegistry() {
   const existing = loadStore().attachedProjects;
   if (existing.length > 0) return;
-  let APPS2;
-  try {
-    const mod = await Promise.resolve().then(() => (init_demo_app_registry(), demo_app_registry_exports));
-    APPS2 = mod.APPS;
-  } catch (err) {
-    console.warn(
-      "[sootsim] seedFromDemoAppRegistry: could not load demo registry:",
-      err.message
-    );
-    return;
-  }
-  if (!Array.isArray(APPS2)) return;
-  const apps = APPS2;
+  const { loadOptionalDemoApps: loadOptionalDemoApps2 } = await Promise.resolve().then(() => (init_optional_demo_registry(), optional_demo_registry_exports));
+  const apps = await loadOptionalDemoApps2();
+  if (apps.length === 0) return;
   mutateStore((store) => {
     for (const app of apps) {
-      if (!import_node_fs4.default.existsSync(app.dir)) continue;
-      const cwd = import_node_path3.default.resolve(app.dir);
+      if (!import_node_fs3.default.existsSync(app.dir)) continue;
+      const cwd = import_node_path2.default.resolve(app.dir);
       const id = projectIdForCwd(cwd);
       if (store.attachedProjects.some((p) => p.id === id)) continue;
       const now = Date.now();
@@ -11560,13 +11185,13 @@ async function seedFromDemoAppRegistry() {
     }
   });
 }
-var import_node_crypto, import_node_fs4, import_node_path3, overrideDir, COST_HISTORY_MAX_AGE_MS;
+var import_node_crypto, import_node_fs3, import_node_path2, overrideDir, COST_HISTORY_MAX_AGE_MS;
 var init_attached_projects = __esm({
   "src/attached-projects.ts"() {
     "use strict";
     import_node_crypto = require("node:crypto");
-    import_node_fs4 = __toESM(require("node:fs"), 1);
-    import_node_path3 = __toESM(require("node:path"), 1);
+    import_node_fs3 = __toESM(require("node:fs"), 1);
+    import_node_path2 = __toESM(require("node:path"), 1);
     init_home_paths();
     overrideDir = null;
     COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
@@ -11575,16 +11200,16 @@ var init_attached_projects = __esm({
 
 // src/agent-sessions.ts
 function sessionDir(sessionId) {
-  return import_node_path4.default.join(getUserDataDir(), "sessions", sessionId);
+  return import_node_path3.default.join(getUserDataDir(), "sessions", sessionId);
 }
 function promptFifoPath(sessionId) {
-  return import_node_path4.default.join(sessionDir(sessionId), "prompt.in");
+  return import_node_path3.default.join(sessionDir(sessionId), "prompt.in");
 }
 function eventsFifoPath(sessionId) {
-  return import_node_path4.default.join(sessionDir(sessionId), "events.out");
+  return import_node_path3.default.join(sessionDir(sessionId), "events.out");
 }
 function transcriptPath(sessionId) {
-  return import_node_path4.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
+  return import_node_path3.default.join(getUserDataDir(), "transcripts", `${sessionId}.log`);
 }
 function pidIsAlive(pid, sessionId) {
   if (!pid) return false;
@@ -11594,7 +11219,7 @@ function pidIsAlive(pid, sessionId) {
     return false;
   }
   if (sessionId) {
-    if (!import_node_fs5.default.existsSync(sessionDir(sessionId))) return false;
+    if (!import_node_fs4.default.existsSync(sessionDir(sessionId))) return false;
   }
   return true;
 }
@@ -11606,11 +11231,11 @@ function resolveSootsimInvocation() {
     const resourcesPath = process.resourcesPath;
     if (resourcesPath) {
       const candidates = [
-        import_node_path4.default.join(resourcesPath, "bin", "sootsim"),
-        import_node_path4.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
+        import_node_path3.default.join(resourcesPath, "bin", "sootsim"),
+        import_node_path3.default.join(resourcesPath, "bin", `sootsim-${process.platform}-${process.arch}`)
       ];
       for (const c of candidates) {
-        if (import_node_fs5.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
+        if (import_node_fs4.default.existsSync(c)) return { cmd: c, prefixArgs: [] };
       }
     }
   }
@@ -11633,15 +11258,15 @@ function tryWorkspaceSootsim() {
     const sootsimDir = resolveSootsimPackageDir();
     if (!sootsimDir) return null;
     const binaryName = `sootsim-${process.platform}-${process.arch}`;
-    const distBinary = import_node_path4.default.join(sootsimDir, "dist-bin", binaryName);
-    if (import_node_fs5.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
-    const distBin = import_node_path4.default.join(sootsimDir, "dist-cli", "bin.js");
-    if (import_node_fs5.default.existsSync(distBin)) {
+    const distBinary = import_node_path3.default.join(sootsimDir, "dist-bin", binaryName);
+    if (import_node_fs4.default.existsSync(distBinary)) return { cmd: distBinary, prefixArgs: [] };
+    const distBin = import_node_path3.default.join(sootsimDir, "dist-cli", "bin.js");
+    if (import_node_fs4.default.existsSync(distBin)) {
       try {
-        const src = import_node_path4.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
-        if (import_node_fs5.default.existsSync(src)) {
-          const srcMtime = import_node_fs5.default.statSync(src).mtimeMs;
-          const buildMtime = import_node_fs5.default.statSync(distBin).mtimeMs;
+        const src = import_node_path3.default.join(sootsimDir, "cli", "commands", "agent-wrapper.ts");
+        if (import_node_fs4.default.existsSync(src)) {
+          const srcMtime = import_node_fs4.default.statSync(src).mtimeMs;
+          const buildMtime = import_node_fs4.default.statSync(distBin).mtimeMs;
           if (buildMtime < srcMtime) {
             console.warn(
               `[sootsim] dist-cli/bin.js is older than agent-wrapper.ts \u2014 rebuild with \`bun run --cwd packages/sootsim build:cli\` (watch:cli:binary builds dist-bin/ instead).`
@@ -11660,22 +11285,22 @@ function tryWorkspaceSootsim() {
 function resolveSootsimPackageDir() {
   try {
     const resolved = require.resolve("sootsim/package.json");
-    return import_node_path4.default.dirname(resolved);
+    return import_node_path3.default.dirname(resolved);
   } catch {
   }
   const here = fileFromImportMeta();
   if (!here) return null;
-  let cur = import_node_path4.default.dirname(here);
+  let cur = import_node_path3.default.dirname(here);
   for (let i = 0; i < 8; i++) {
-    const pkg = import_node_path4.default.join(cur, "package.json");
+    const pkg = import_node_path3.default.join(cur, "package.json");
     try {
-      if (import_node_fs5.default.existsSync(pkg)) {
-        const parsed = JSON.parse(import_node_fs5.default.readFileSync(pkg, "utf8"));
+      if (import_node_fs4.default.existsSync(pkg)) {
+        const parsed = JSON.parse(import_node_fs4.default.readFileSync(pkg, "utf8"));
         if (parsed.name === "sootsim") return cur;
       }
     } catch {
     }
-    const parent = import_node_path4.default.dirname(cur);
+    const parent = import_node_path3.default.dirname(cur);
     if (parent === cur) break;
     cur = parent;
   }
@@ -11691,28 +11316,28 @@ function fileFromImportMeta() {
   }
 }
 async function withStartLock(projectId, provider, fn) {
-  const lockDir = import_node_path4.default.join(getUserDataDir(), "locks");
-  import_node_fs5.default.mkdirSync(lockDir, { recursive: true });
+  const lockDir = import_node_path3.default.join(getUserDataDir(), "locks");
+  import_node_fs4.default.mkdirSync(lockDir, { recursive: true });
   try {
-    import_node_fs5.default.chmodSync(lockDir, 448);
+    import_node_fs4.default.chmodSync(lockDir, 448);
   } catch {
   }
-  const lockPath = import_node_path4.default.join(lockDir, `start-${projectId}-${provider}.lock`);
+  const lockPath = import_node_path3.default.join(lockDir, `start-${projectId}-${provider}.lock`);
   const deadline = Date.now() + 4e3;
   let fd = null;
   while (fd === null) {
     try {
-      fd = import_node_fs5.default.openSync(
+      fd = import_node_fs4.default.openSync(
         lockPath,
-        import_node_fs5.constants.O_WRONLY | import_node_fs5.constants.O_CREAT | import_node_fs5.constants.O_EXCL,
+        import_node_fs4.constants.O_WRONLY | import_node_fs4.constants.O_CREAT | import_node_fs4.constants.O_EXCL,
         384
       );
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const stale = Number(import_node_fs5.default.readFileSync(lockPath, "utf8").trim());
+        const stale = Number(import_node_fs4.default.readFileSync(lockPath, "utf8").trim());
         if (stale && !isProcessAlive(stale)) {
-          import_node_fs5.default.unlinkSync(lockPath);
+          import_node_fs4.default.unlinkSync(lockPath);
           continue;
         }
       } catch {
@@ -11726,15 +11351,15 @@ async function withStartLock(projectId, provider, fn) {
     }
   }
   try {
-    import_node_fs5.default.writeFileSync(fd, String(process.pid));
+    import_node_fs4.default.writeFileSync(fd, String(process.pid));
     return await fn();
   } finally {
     try {
-      import_node_fs5.default.closeSync(fd);
+      import_node_fs4.default.closeSync(fd);
     } catch {
     }
     try {
-      import_node_fs5.default.unlinkSync(lockPath);
+      import_node_fs4.default.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -11748,25 +11373,25 @@ function isProcessAlive(pid) {
   }
 }
 function mkfifoSync(p) {
-  const parent = import_node_path4.default.dirname(p);
-  import_node_fs5.default.mkdirSync(parent, { recursive: true });
+  const parent = import_node_path3.default.dirname(p);
+  import_node_fs4.default.mkdirSync(parent, { recursive: true });
   try {
-    import_node_fs5.default.chmodSync(parent, 448);
+    import_node_fs4.default.chmodSync(parent, 448);
   } catch {
   }
-  if (import_node_fs5.default.existsSync(p)) {
+  if (import_node_fs4.default.existsSync(p)) {
     try {
-      const stat = import_node_fs5.default.statSync(p);
+      const stat = import_node_fs4.default.statSync(p);
       if (stat.isFIFO()) {
         try {
-          import_node_fs5.default.chmodSync(p, 384);
+          import_node_fs4.default.chmodSync(p, 384);
         } catch {
         }
         return;
       }
-      import_node_fs5.default.unlinkSync(p);
+      import_node_fs4.default.unlinkSync(p);
     } catch {
-      import_node_fs5.default.unlinkSync(p);
+      import_node_fs4.default.unlinkSync(p);
     }
   }
   const result = (0, import_node_child_process.spawnSync)("mkfifo", ["-m", "600", p]);
@@ -11806,10 +11431,10 @@ async function startSession(opts) {
     const transcript = transcriptPath(session.id);
     mkfifoSync(promptIn);
     mkfifoSync(eventsOut);
-    const transcriptDir = import_node_path4.default.dirname(transcript);
-    import_node_fs5.default.mkdirSync(transcriptDir, { recursive: true });
+    const transcriptDir = import_node_path3.default.dirname(transcript);
+    import_node_fs4.default.mkdirSync(transcriptDir, { recursive: true });
     try {
-      import_node_fs5.default.chmodSync(transcriptDir, 448);
+      import_node_fs4.default.chmodSync(transcriptDir, 448);
     } catch {
     }
     const { cmd, prefixArgs } = resolveSootsimInvocation();
@@ -11860,7 +11485,7 @@ async function startSession(opts) {
         }
       }
       try {
-        import_node_fs5.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
+        import_node_fs4.default.rmSync(sessionDir(session.id), { recursive: true, force: true });
       } catch {
       }
       updateSessionStatus(session.id, { status: "ended" });
@@ -11888,18 +11513,18 @@ async function sendPrompt(sessionId, prompt) {
     );
   }
   const fifo = promptFifoPath(sessionId);
-  if (!import_node_fs5.default.existsSync(fifo)) {
+  if (!import_node_fs4.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `prompt FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs5.default.openSync(fifo, import_node_fs5.constants.O_WRONLY);
+  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_WRONLY);
   try {
     const wireText = encodeAgentPromptEnvelope(prompt);
     if (!wireText) {
       throw new AgentSessionError("EMPTY_PROMPT", "prompt text is empty");
     }
-    import_node_fs5.default.writeSync(fd, wireText + "\n");
+    import_node_fs4.default.writeSync(fd, wireText + "\n");
   } finally {
-    import_node_fs5.default.closeSync(fd);
+    import_node_fs4.default.closeSync(fd);
   }
   updateSessionStatus(sessionId, {
     lastPrompt: prompt.displayText ?? prompt.text,
@@ -11921,7 +11546,7 @@ async function endSession(sessionId) {
   const base = getUserDataDir();
   if (dir.startsWith(base)) {
     try {
-      import_node_fs5.default.rmSync(dir, { recursive: true, force: true });
+      import_node_fs4.default.rmSync(dir, { recursive: true, force: true });
     } catch {
     }
   }
@@ -11929,11 +11554,11 @@ async function endSession(sessionId) {
 }
 function subscribeEvents(sessionId, onEvent) {
   const fifo = eventsFifoPath(sessionId);
-  if (!import_node_fs5.default.existsSync(fifo)) {
+  if (!import_node_fs4.default.existsSync(fifo)) {
     throw new AgentSessionError("NO_FIFO", `events FIFO missing: ${fifo}`);
   }
-  const fd = import_node_fs5.default.openSync(fifo, import_node_fs5.constants.O_RDWR);
-  const stream = import_node_fs5.default.createReadStream("", { fd, autoClose: true });
+  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_RDWR);
+  const stream = import_node_fs4.default.createReadStream("", { fd, autoClose: true });
   const rl = import_node_readline.default.createInterface({ input: stream, crlfDelay: Infinity });
   rl.on("line", (line) => {
     const event = parseAgentEventLine(line);
@@ -11954,7 +11579,7 @@ function subscribeEvents(sessionId, onEvent) {
   };
 }
 async function waitForFirstEvent(fifo, predicate, timeoutMs) {
-  const fd = import_node_fs5.default.openSync(fifo, import_node_fs5.constants.O_RDWR | import_node_fs5.constants.O_NONBLOCK);
+  const fd = import_node_fs4.default.openSync(fifo, import_node_fs4.constants.O_RDWR | import_node_fs4.constants.O_NONBLOCK);
   const buf = Buffer.alloc(8192);
   let leftover = "";
   const deadline = Date.now() + timeoutMs;
@@ -11962,7 +11587,7 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     while (Date.now() < deadline) {
       let n = 0;
       try {
-        n = import_node_fs5.default.readSync(fd, buf, 0, buf.length, null);
+        n = import_node_fs4.default.readSync(fd, buf, 0, buf.length, null);
       } catch (err) {
         if (err.code !== "EAGAIN") throw err;
         n = 0;
@@ -11982,17 +11607,17 @@ async function waitForFirstEvent(fifo, predicate, timeoutMs) {
     }
     return null;
   } finally {
-    import_node_fs5.default.closeSync(fd);
+    import_node_fs4.default.closeSync(fd);
   }
 }
-var import_node_child_process, import_node_crypto2, import_node_fs5, import_node_path4, import_node_readline, AgentSessionError;
+var import_node_child_process, import_node_crypto2, import_node_fs4, import_node_path3, import_node_readline, AgentSessionError;
 var init_agent_sessions = __esm({
   "src/agent-sessions.ts"() {
     "use strict";
     import_node_child_process = require("node:child_process");
     import_node_crypto2 = require("node:crypto");
-    import_node_fs5 = __toESM(require("node:fs"), 1);
-    import_node_path4 = __toESM(require("node:path"), 1);
+    import_node_fs4 = __toESM(require("node:fs"), 1);
+    import_node_path3 = __toESM(require("node:path"), 1);
     import_node_readline = __toESM(require("node:readline"), 1);
     init_agent_events();
     init_agent_prompt();
@@ -12021,12 +11646,12 @@ function mapFrameworkToProjectFramework(fw) {
   if (fw === "one" || fw === "vxrn") return "one";
   return "unknown";
 }
-var import_node_fs6, import_node_path5, WS_OPEN, AgentHost;
+var import_node_fs5, import_node_path4, WS_OPEN, AgentHost;
 var init_agent_host = __esm({
   "src/host/agent-host.ts"() {
     "use strict";
-    import_node_fs6 = __toESM(require("node:fs"), 1);
-    import_node_path5 = __toESM(require("node:path"), 1);
+    import_node_fs5 = __toESM(require("node:fs"), 1);
+    import_node_path4 = __toESM(require("node:path"), 1);
     init_dev_server_scanner();
     init_agent_sessions();
     init_attached_projects();
@@ -12188,7 +11813,7 @@ var init_agent_host = __esm({
         );
         const project = upsertProject({
           cwd: match.cwd,
-          name: match.projectName ?? import_node_path5.default.basename(match.cwd),
+          name: match.projectName ?? import_node_path4.default.basename(match.cwd),
           preferredProvider: input.provider ?? existing?.preferredProvider,
           sourceRoots: existing?.sourceRoots ?? [match.cwd],
           knownBundleUrls,
@@ -12199,18 +11824,18 @@ var init_agent_host = __esm({
       }
       getTranscript(sessionId) {
         const p = transcriptPath(sessionId);
-        if (!import_node_fs6.default.existsSync(p)) {
+        if (!import_node_fs5.default.existsSync(p)) {
           return { error: "transcript not found", code: "NO_TRANSCRIPT" };
         }
-        return import_node_fs6.default.readFileSync(p, "utf8");
+        return import_node_fs5.default.readFileSync(p, "utf8");
       }
       getPaths() {
         const dir = getUserDataDir();
         return {
           userDataDir: dir,
-          storeFile: import_node_path5.default.join(dir, "attached-projects.json"),
-          sessionsDir: import_node_path5.default.join(dir, "sessions"),
-          transcriptsDir: import_node_path5.default.join(dir, "transcripts")
+          storeFile: import_node_path4.default.join(dir, "attached-projects.json"),
+          sessionsDir: import_node_path4.default.join(dir, "sessions"),
+          transcriptsDir: import_node_path4.default.join(dir, "transcripts")
         };
       }
       // --- subscription management ---
@@ -12825,7 +12450,7 @@ function buildChromiumUrlCommand(url, options = {}) {
   };
 }
 async function spawnLaunch(command, args, detached) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = (0, import_child_process3.spawn)(command, args, {
       detached,
       stdio: "ignore"
@@ -12833,7 +12458,7 @@ async function spawnLaunch(command, args, detached) {
     child.once("error", reject);
     child.once("spawn", () => {
       if (detached) child.unref();
-      resolve7(child.pid);
+      resolve6(child.pid);
     });
   });
 }
@@ -13290,7 +12915,7 @@ var init_bridge_host = __esm({
         );
       }
       bindOnce(port, _silent) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve6, reject) => {
           const server = (0, import_http3.createServer)((req, res) => this.handleHttpRequest(req, res));
           let settled = false;
           const onError = (err) => {
@@ -13322,7 +12947,7 @@ var init_bridge_host = __esm({
                 this.wss?.emit("connection", ws, req);
               });
             });
-            resolve7();
+            resolve6();
           });
         });
       }
@@ -14297,7 +13922,7 @@ var init_bridge_host = __esm({
       async sendCommand(cmd) {
         const sim = await this.waitForSim(cmd.simId);
         const id = this.nextCommandId++;
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve6, reject) => {
           const timeout = setTimeout(() => {
             this.pendingCommands.delete(id);
             this.broadcastSimClientStates();
@@ -14309,7 +13934,7 @@ var init_bridge_host = __esm({
               clearTimeout(timeout);
               this.pendingCommands.delete(id);
               this.broadcastSimClientStates();
-              resolve7(value);
+              resolve6(value);
             },
             reject: (error) => {
               clearTimeout(timeout);
@@ -14335,23 +13960,23 @@ var init_bridge_host = __esm({
       async openPathInEditor(filePath, line, column) {
         const loc = line != null ? `:${line}${column != null ? `:${column}` : ""}` : "";
         const target = `${filePath}${loc}`;
-        const trySpawn = (cmd, args) => new Promise((resolve7) => {
+        const trySpawn = (cmd, args) => new Promise((resolve6) => {
           try {
             const child = (0, import_child_process4.spawn)(cmd, args, { detached: true, stdio: "ignore" });
             let settled = false;
             child.on("error", () => {
               if (settled) return;
               settled = true;
-              resolve7(false);
+              resolve6(false);
             });
             child.on("spawn", () => {
               if (settled) return;
               settled = true;
               child.unref();
-              resolve7(true);
+              resolve6(true);
             });
           } catch {
-            resolve7(false);
+            resolve6(false);
           }
         });
         const envEditor = process.env.REACT_EDITOR || process.env.EDITOR;
@@ -14578,7 +14203,7 @@ var init_bridge_host = __esm({
         for (let attempt = 0; attempt < attempts; attempt++) {
           const sim = this.getOpenSim(simId);
           if (sim) return sim;
-          await new Promise((resolve7) => setTimeout(resolve7, intervalMs));
+          await new Promise((resolve6) => setTimeout(resolve6, intervalMs));
         }
         throw new Error(simId ? `no sim connected with id ${simId}` : "no sim connected");
       }
@@ -14801,9 +14426,9 @@ var init_bridge_host = __esm({
 
 // cli/parent-pid.ts
 function getParentPid(pid) {
-  if (!cached2) cached2 = build();
+  if (!cached3) cached3 = build();
   try {
-    return cached2(pid);
+    return cached3(pid);
   } catch {
     return null;
   }
@@ -14877,14 +14502,14 @@ function buildDarwinLsof() {
     }
   };
 }
-var import_child_process5, import_fs4, import_module, cached2, PROC_PIDTBSDINFO, PROC_BSDINFO_SIZE, PBI_PPID_OFFSET;
+var import_child_process5, import_fs4, import_module, cached3, PROC_PIDTBSDINFO, PROC_BSDINFO_SIZE, PBI_PPID_OFFSET;
 var init_parent_pid = __esm({
   "cli/parent-pid.ts"() {
     "use strict";
     import_child_process5 = require("child_process");
     import_fs4 = require("fs");
     import_module = require("module");
-    cached2 = null;
+    cached3 = null;
     PROC_PIDTBSDINFO = 3;
     PROC_BSDINFO_SIZE = 216;
     PBI_PPID_OFFSET = 16;
@@ -15095,7 +14720,7 @@ function createBridge(wsPort, opts = {}) {
   const pending = /* @__PURE__ */ new Map();
   const ws = new import_ws3.WebSocket(`ws://localhost:${wsPort}`);
   const identity = getCliIdentity();
-  const ready = new Promise((resolve7, reject) => {
+  const ready = new Promise((resolve6, reject) => {
     ws.on("open", () => {
       try {
         ws.send(
@@ -15109,7 +14734,7 @@ function createBridge(wsPort, opts = {}) {
         );
       } catch {
       }
-      resolve7();
+      resolve6();
     });
     ws.on("error", (err) => {
       const cause = err.message ? `: ${err.message}` : "";
@@ -15175,7 +14800,7 @@ function createBridge(wsPort, opts = {}) {
       const sendOnce = async (defaultSimId) => {
         await ready;
         const id = nextId++;
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve6, reject) => {
           const timeout = setTimeout(() => {
             pending.delete(id);
             reject(
@@ -15187,7 +14812,7 @@ function createBridge(wsPort, opts = {}) {
           pending.set(id, {
             resolve: (v) => {
               clearTimeout(timeout);
-              resolve7(v);
+              resolve6(v);
             },
             reject: (e) => {
               clearTimeout(timeout);
@@ -15632,19 +15257,19 @@ async function createFramedScreenshotComposer(browser) {
   }
   return {
     async compose(rawPng, model) {
-      const cached3 = await getCachedPage(model);
+      const cached4 = await getCachedPage(model);
       const rawImageDataUrl = `data:image/png;base64,${rawPng.toString("base64")}`;
-      await cached3.page.setContent(renderFrameHtml(cached3.layout, rawImageDataUrl), {
+      await cached4.page.setContent(renderFrameHtml(cached4.layout, rawImageDataUrl), {
         waitUntil: "load"
       });
-      await cached3.page.waitForTimeout(20);
-      return await cached3.page.screenshot({
+      await cached4.page.waitForTimeout(20);
+      return await cached4.page.screenshot({
         type: "png",
         clip: {
           x: 0,
           y: 0,
-          width: cached3.layout.outerWidth,
-          height: cached3.layout.outerHeight
+          width: cached4.layout.outerWidth,
+          height: cached4.layout.outerHeight
         },
         omitBackground: true
       });
@@ -15877,14 +15502,14 @@ var init_flow_file = __esm({
 function getBaseDir() {
   const explicit = process.env[SESSION_FILE_ENV];
   if (explicit?.trim()) {
-    return (0, import_node_path6.dirname)((0, import_node_path6.resolve)(explicit));
+    return (0, import_node_path5.dirname)((0, import_node_path5.resolve)(explicit));
   }
   return electronUserDataDir();
 }
 function getSharedDesktopAuthFilePath() {
   const explicit = process.env[SESSION_FILE_ENV];
-  if (explicit?.trim()) return (0, import_node_path6.resolve)(explicit);
-  return (0, import_node_path6.join)(getBaseDir(), "desktop-auth.json");
+  if (explicit?.trim()) return (0, import_node_path5.resolve)(explicit);
+  return (0, import_node_path5.join)(getBaseDir(), "desktop-auth.json");
 }
 function normalizeUser(input) {
   if (!input || typeof input !== "object") return null;
@@ -15930,26 +15555,26 @@ function normalizeSession(input) {
 }
 function readSharedDesktopAuthSession() {
   const filepath = getSharedDesktopAuthFilePath();
-  if (!(0, import_node_fs7.existsSync)(filepath)) return null;
+  if (!(0, import_node_fs6.existsSync)(filepath)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(filepath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs6.readFileSync)(filepath, "utf8"));
     const normalized = normalizeSession(parsed);
     if (!normalized) {
-      (0, import_node_fs7.rmSync)(filepath, { force: true });
+      (0, import_node_fs6.rmSync)(filepath, { force: true });
       return null;
     }
     return normalized;
   } catch {
-    (0, import_node_fs7.rmSync)(filepath, { force: true });
+    (0, import_node_fs6.rmSync)(filepath, { force: true });
     return null;
   }
 }
-var import_node_fs7, import_node_path6, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
+var import_node_fs6, import_node_path5, SESSION_VERSION, SESSION_FILE_ENV, DEFAULT_ORIGIN;
 var init_shared_session = __esm({
   "src/auth/shared-session.ts"() {
     "use strict";
-    import_node_fs7 = require("node:fs");
-    import_node_path6 = require("node:path");
+    import_node_fs6 = require("node:fs");
+    import_node_path5 = require("node:path");
     init_home_paths();
     SESSION_VERSION = 1;
     SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
@@ -15959,13 +15584,13 @@ var init_shared_session = __esm({
 
 // cli/auth.ts
 function credentialsPath() {
-  return (0, import_node_path7.join)(electronUserDataDir(), "credentials.json");
+  return (0, import_node_path6.join)(electronUserDataDir(), "credentials.json");
 }
 function readStoredApiKey() {
   const file = credentialsPath();
-  if (!(0, import_node_fs8.existsSync)(file)) return null;
+  if (!(0, import_node_fs7.existsSync)(file)) return null;
   try {
-    const parsed = JSON.parse((0, import_node_fs8.readFileSync)(file, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs7.readFileSync)(file, "utf8"));
     if (parsed.version !== 1) return null;
     if (typeof parsed.apiKey !== "string" || !parsed.apiKey.startsWith("sk_sootsim_")) {
       return null;
@@ -16021,12 +15646,12 @@ function resolveCliAuth() {
 function authHeaderValue(auth) {
   return auth.kind === "api-key" ? `Bearer ${auth.secret}` : `Bearer ${auth.token}`;
 }
-var import_node_fs8, import_node_path7, GITHUB_TOKEN_PREFIXES;
+var import_node_fs7, import_node_path6, GITHUB_TOKEN_PREFIXES;
 var init_auth = __esm({
   "cli/auth.ts"() {
     "use strict";
-    import_node_fs8 = require("node:fs");
-    import_node_path7 = require("node:path");
+    import_node_fs7 = require("node:fs");
+    import_node_path6 = require("node:path");
     init_shared_session();
     init_home_paths();
     GITHUB_TOKEN_PREFIXES = ["ghs_", "ghp_", "gho_", "ghu_", "github_pat_"];
@@ -16203,7 +15828,7 @@ function clearFlowScopedVars() {
   flowScopedVars.clear();
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 function resolveFlowScreenshotPath(screenshotDir, name) {
   return resolveFlowScreenshotPathWithMode(screenshotDir, name, {
@@ -16434,8 +16059,9 @@ var init_bridge_flow_runner = __esm({
         const result = await this.evaluate(`(() => {
       const rec = window.__sootsimRecorder
       if (!rec) return { ok: false, error: 'recorder unavailable on this page' }
-      if (rec.state() === 'recording') return { ok: true, format: 'webm' }
-      return rec.start({ format: 'webm', fps: 24 })
+      const format = ${JSON.stringify(this.opts.recordingFormat ?? "webm")}
+      if (rec.state() === 'recording') return { ok: true, format }
+      return rec.start({ format, fps: 24 })
     })()`);
         if (!result?.ok) {
           throw new Error(result?.error || "recording unavailable on this page");
@@ -16480,9 +16106,11 @@ var init_bridge_flow_runner = __esm({
           throw new Error("recording requested but no video buffer was produced");
         }
         fs7.mkdirSync(this.opts.recordingOutputDir, { recursive: true });
+        const videoMime = stopped.mime || this.opts.recordingFormat || "video/webm";
+        const extension = videoMime.includes("mp4") ? "mp4" : "webm";
         const outputPath = path7.join(
           this.opts.recordingOutputDir,
-          `sootsim-${Date.now()}.webm`
+          `sootsim-${Date.now()}.${extension}`
         );
         fs7.writeFileSync(outputPath, Buffer.concat(chunks));
         return outputPath;
@@ -17838,7 +17466,7 @@ var skill4 = {
 
 // src/skills/builtin/test-flow.ts
 function sleep2(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 var skill5 = {
   name: "test-flow",