yaver-feedback-react-native 0.9.0 → 0.9.3

package/dist/YaverFeedback.js

@@ -6,8 +6,17 @@ const Discovery_1 = require("./Discovery");
 const BlackBox_1 = require("./BlackBox");
 const P2PClient_1 = require("./P2PClient");
 const ShakeDetector_1 = require("./ShakeDetector");
+const storeShots_1 = require("./storeShots");
 const auth_1 = require("./auth");
 const preferences_1 = require("./preferences");
+const dogfoodPolicy_1 = require("./dogfoodPolicy");
+const deviceDogfood_1 = require("./deviceDogfood");
+function unrefTimer(timer) {
+    const maybeNodeTimer = timer;
+    if (typeof maybeNodeTimer.unref === 'function') {
+        maybeNodeTimer.unref();
+    }
+}
 // Is this JS runtime the Yaver mobile app's super-host bridge? The
 // YaverInfo native module is only registered inside Yaver's container
 // (mobile/ios/Yaver/YaverInfo.{swift,m} + Android counterpart); a
@@ -133,10 +142,19 @@ if (IS_HOST_MODE) {
 let config = null;
 let enabled = false;
 let p2pClient = null;
+let renderP2PClient = null;
 let shakeDetector = null;
+/** Unsubscribe for the BlackBox command handler registered by init(). Held so
+ *  a re-init (or destroy) can drop the old one instead of stacking. */
+let commandUnsubscribe = null;
 let p2pAuthToken = null;
 let p2pRelayPassword = '';
+/** Pending BlackBox auto-start retry. Held so destroy()/re-init can cancel it
+ *  instead of leaving a timer chain running against a torn-down config. */
+let autoStartTimer = null;
 let reportLaunchInFlight = false;
+let crashReportInFlight = false;
+let dogfoodOnboarding = null;
 /** Resolve the user's relay password by validating their auth token
  *  against Convex. Used whenever we (re)build the P2PClient so a
  *  relay-routed agentUrl carries a valid X-Relay-Password — without
@@ -182,6 +200,7 @@ async function resolveRelayPassword(authToken, convexUrl) {
 /** Ring buffer of captured errors. */
 let errorBuffer = [];
 let maxErrors = 5;
+let crashHandlerInstalled = false;
 /** Track whether BlackBox was running before disable (to restart on enable). */
 let blackBoxWasStreaming = false;
 /**
@@ -203,40 +222,37 @@ const flagCache = new Map();
  */
 class YaverFeedback {
     static async resolveP2PAuthToken() {
-        if (!config?.authToken)
-            return null;
-        if (!config.preferredDeviceId)
-            return config.authToken;
-        const devices = await (0, auth_1.listReachableDevices)(config.authToken);
-        const all = [...devices.owned, ...devices.shared];
-        const selected = all.find((device) => device.deviceId === config?.preferredDeviceId);
-        if (!selected || !selected.isGuest || selected.accessScope !== 'shared-scoped') {
-            return config.authToken;
-        }
-        if (!selected.hostUserId) {
-            return config.authToken;
-        }
-        const delegated = await (0, auth_1.mintGuestSdkToken)(config.authToken, selected.hostUserId, selected.deviceId);
-        return delegated.token;
+        return config?.authToken ?? null;
     }
     static async rebuildP2PClient(agentUrl) {
-        if (!config)
+        const currentConfig = config;
+        if (!currentConfig)
             return;
-        const effectiveUrl = agentUrl ?? config.agentUrl;
+        const effectiveUrl = agentUrl ?? currentConfig.agentUrl;
         if (!effectiveUrl) {
             p2pClient = null;
+            renderP2PClient = null;
             p2pAuthToken = null;
             return;
         }
         const token = await YaverFeedback.resolveP2PAuthToken();
+        // reset() can clear config while relay-password resolution is awaiting.
+        // Do not resurrect a client from that stale init generation.
+        if (config !== currentConfig)
+            return;
         if (!token) {
             p2pClient = null;
+            renderP2PClient = null;
             p2pAuthToken = null;
             return;
         }
         p2pAuthToken = token;
         const rp = await resolveRelayPassword(token);
+        if (config !== currentConfig)
+            return;
         p2pClient = new P2PClient_1.P2PClient(effectiveUrl, token, rp);
+        const renderUrl = currentConfig.renderAgentUrl || effectiveUrl;
+        renderP2PClient = renderUrl === effectiveUrl ? p2pClient : new P2PClient_1.P2PClient(renderUrl, token, rp);
     }
     /**
      * Initialize the feedback SDK with the given configuration.
@@ -245,12 +261,127 @@ class YaverFeedback {
      * If no `agentUrl` is provided, the SDK will attempt auto-discovery
      * via `YaverDiscovery` on the first `startReport()` call.
      */
+    /** The runtime lane, when running on web inside a Yaver preview WebView. */
+    static detectWebLane() {
+        try {
+            if (react_native_1.Platform.OS !== 'web' || typeof window === 'undefined')
+                return null;
+            const l = String(window.__yaverLane || '').toLowerCase();
+            if (l === 'browser' || l === 'webrtc')
+                return l;
+        }
+        catch { /* noop */ }
+        return null;
+    }
+    /**
+     * Mount a draggable DOM floating "Y" icon for the BROWSER lane (RN-web). It
+     * lives in the WebView's document.body (position:fixed, max z-index), so it
+     * renders ON TOP of the page inside the WebView and is never occluded by the
+     * fullScreen preview modal — the one occlusion-proof affordance on iOS.
+     * Tap opens the SDK's existing report flow (the RN FeedbackModal renders in
+     * the same WebView DOM, also un-occluded). No-op off-web or off-lane, and
+     * idempotent (a re-init reuses the existing node).
+     */
+    static mountBrowserLaneIcon() {
+        if (YaverFeedback.detectWebLane() !== 'browser')
+            return;
+        try {
+            const doc = globalThis.document;
+            if (!doc || !doc.body)
+                return;
+            if (doc.getElementById('yaver-feedback-btn'))
+                return; // idempotent
+            const btn = doc.createElement('div');
+            btn.id = 'yaver-feedback-btn';
+            btn.textContent = 'Y';
+            btn.title = 'Yaver Feedback — drag to move · tap to report';
+            btn.style.cssText =
+                'position:fixed;bottom:20px;right:20px;width:44px;height:44px;border-radius:50%;' +
+                    'background:#6366f1;color:#fff;display:flex;align-items:center;justify-content:center;' +
+                    'cursor:pointer;z-index:99999;font-size:18px;font-weight:bold;touch-action:none;' +
+                    'box-shadow:0 4px 12px rgba(99,102,241,0.4);transition:transform 0.2s;';
+            const drag = { on: false, moved: false, sx: 0, sy: 0, ox: 0, oy: 0 };
+            const w = window;
+            const applyPos = (x, y) => {
+                const m = 8;
+                const nx = Math.max(m, Math.min(w.innerWidth - 44 - m, x));
+                const ny = Math.max(m, Math.min(w.innerHeight - 44 - m, y));
+                btn.style.left = nx + 'px';
+                btn.style.top = ny + 'px';
+                btn.style.right = 'auto';
+                btn.style.bottom = 'auto';
+                try {
+                    localStorage.setItem('yaver-feedback-btn-pos', JSON.stringify({ x: nx, y: ny }));
+                }
+                catch { /* noop */ }
+            };
+            try {
+                const s = localStorage.getItem('yaver-feedback-btn-pos');
+                if (s) {
+                    const p = JSON.parse(s);
+                    if (typeof p?.x === 'number')
+                        applyPos(p.x, p.y);
+                }
+            }
+            catch { /* noop */ }
+            btn.addEventListener('pointerdown', (e) => {
+                drag.on = true;
+                drag.moved = false;
+                const r = btn.getBoundingClientRect();
+                drag.sx = e.clientX;
+                drag.sy = e.clientY;
+                drag.ox = r.left;
+                drag.oy = r.top;
+                btn.setPointerCapture(e.pointerId);
+                btn.style.transition = 'none';
+            });
+            btn.addEventListener('pointermove', (e) => {
+                if (!drag.on)
+                    return;
+                const dx = e.clientX - drag.sx, dy = e.clientY - drag.sy;
+                if (Math.abs(dx) + Math.abs(dy) > 5)
+                    drag.moved = true;
+                if (drag.moved)
+                    applyPos(drag.ox + dx, drag.oy + dy);
+            });
+            const end = (e) => {
+                if (!drag.on)
+                    return;
+                drag.on = false;
+                btn.style.transition = 'transform 0.2s';
+                try {
+                    btn.releasePointerCapture(e.pointerId);
+                }
+                catch { /* noop */ }
+                if (!drag.moved) {
+                    try {
+                        void YaverFeedback.startReport();
+                    }
+                    catch { /* noop */ }
+                }
+            };
+            btn.addEventListener('pointerup', end);
+            btn.addEventListener('pointercancel', end);
+            // Also answer the host's forwarded shake (Yaver injects yaver-feedback:launch).
+            const launch = () => { try {
+                void YaverFeedback.startReport();
+            }
+            catch { /* noop */ } };
+            window.addEventListener('yaver-feedback:launch', launch);
+            window.__yaverFeedbackLaunch = launch;
+            doc.body.appendChild(btn);
+        }
+        catch { /* noop — never break the guest app over a feedback affordance */ }
+    }
     static init(cfg) {
         config = {
             trigger: 'shake',
             maxRecordingDuration: 120,
             autoLogin: true,
             ...cfg,
+            agentUrl: cfg.codingAgentUrl || cfg.agentUrl,
+            codingDeviceId: cfg.codingDeviceId || cfg.preferredDeviceId,
+            renderDeviceId: cfg.renderDeviceId || cfg.codingDeviceId || cfg.preferredDeviceId,
         };
         if (IS_HOST_MODE) {
             // sfmg / talos / etc. running inside Yaver mobile (compile-time
@@ -272,6 +403,9 @@ class YaverFeedback {
             }
             maxErrors = cfg.maxCapturedErrors ?? 5;
             errorBuffer = [];
+            if (cfg.crashReporting?.enabled && cfg.crashReporting?.installGlobalHandler) {
+                YaverFeedback.installCrashHandler();
+            }
             return;
         }
         if (config.disableShakeGesture && (!config.quickIcon || config.quickIcon === 'auto')) {
@@ -321,12 +455,17 @@ class YaverFeedback {
             // is set, so set a placeholder header here that won't 401 a
             // direct-LAN url and will be overwritten before any relay hop.
             p2pClient = new P2PClient_1.P2PClient(config.agentUrl, config.authToken ?? '', p2pRelayPassword);
+            const renderUrl = config.renderAgentUrl || config.agentUrl;
+            renderP2PClient = renderUrl === config.agentUrl
+                ? p2pClient
+                : new P2PClient_1.P2PClient(renderUrl, config.authToken ?? '', p2pRelayPassword);
             if (config.authToken) {
                 void YaverFeedback.rebuildP2PClient(config.agentUrl);
             }
         }
         else {
             p2pClient = null;
+            renderP2PClient = null;
             // Auto-discover agent in the background when convexUrl or LAN is available
             if (enabled && (config.authToken || config.preferredDeviceId)) {
                 YaverFeedback.discoverAgent();
@@ -335,23 +474,23 @@ class YaverFeedback {
         // Set up error capture buffer size
         maxErrors = cfg.maxCapturedErrors ?? 5;
         errorBuffer = [];
-        // Wire up shake detection when trigger is 'shake'
-        if (shakeDetector) {
-            shakeDetector.stop();
-            shakeDetector = null;
-        }
-        if (enabled && config.trigger === 'shake' && !config.disableShakeGesture) {
-            shakeDetector = new ShakeDetector_1.ShakeDetector();
-            shakeDetector.start(() => {
-                YaverFeedback.notifyShake();
-                if (config?.reportingOnly) {
-                    YaverFeedback.sendAutoReport();
-                }
-                else {
-                    YaverFeedback.startReport();
-                }
-            });
+        if (cfg.crashReporting?.enabled && cfg.crashReporting?.installGlobalHandler) {
+            YaverFeedback.installCrashHandler();
         }
+        // Wire up shake detection when trigger is 'shake'. Rebuild from scratch:
+        // config was just replaced, so the old detector may be closing over stale
+        // settings.
+        YaverFeedback.stopShakeDetector();
+        YaverFeedback.syncShakeDetector();
+        // Browser lane (RN-web inside Yaver's fullScreen WebView preview): the
+        // native shake module doesn't exist on web, and Yaver's own container
+        // overlay is OCCLUDED behind the WebView modal on iOS. So mount an
+        // occlusion-proof DRAGGABLE DOM icon INSIDE the WebView — same pattern as
+        // yaver-feedback-web. Lane is stamped by Yaver via
+        // window.__yaverLane='browser' (mobile PREVIEW_LANE_SCRIPT). See
+        // docs/audits/feedback-sdk-lanes-audit-2026-07-28.md.
+        if (enabled)
+            YaverFeedback.mountBrowserLaneIcon();
         // Wire up BlackBox command handlers for reload + status signals from
         // the agent. Opens an SSE channel the agent uses to:
         //   - broadcast reload_bundle so the phone picks up a fresh Hermes
@@ -360,7 +499,14 @@ class YaverFeedback {
         //     assets…", "Done") so the SDK can surface it like a normal
         //     "Working…" spinner instead of a silent 60-second freeze.
         if (enabled) {
-            BlackBox_1.BlackBox.onCommand((cmd) => {
+            // onCommand appends to a static array and hands back an unsubscribe.
+            // Dropping that unsubscribe meant every re-init stacked another handler
+            // on top of the last, so an app that re-initialised (say, a settings
+            // toggle) reloaded twice per agent command, then three times, and so on.
+            // destroy() never cleared them either. Drop the previous registration
+            // first so init() is idempotent here.
+            commandUnsubscribe?.();
+            commandUnsubscribe = BlackBox_1.BlackBox.onCommand((cmd) => {
                 if (cmd.command === 'reload') {
                     if (cfg.onReload) {
                         cfg.onReload();
@@ -423,17 +569,24 @@ class YaverFeedback {
             // SFMG used to call BlackBox.start() inside YaverFeedbackWidget
             // after auth — that path still works (start() is idempotent), so
             // upgrading SDK without removing the manual call is safe.
+            //   4. RETRY, rather than checking once. This was a single 500ms
+            //      timeout, and on a cold start it could not succeed: an app that
+            //      passes neither agentUrl nor authToken to init() (the normal
+            //      case — they're restored from storage) gets its session from
+            //      `void hydrateSession()`, which reads two AsyncStorage keys and
+            //      then awaits discoverAgent(), a Convex round trip plus LAN
+            //      probing. That does not finish in 500ms, so the check found no
+            //      agentUrl, gave up, and BlackBox never started — meaning no SSE
+            //      channel, so the agent's `reload_bundle` command had nowhere to
+            //      land and Hermes hot reload silently did nothing until the user
+            //      shook the device and drove discovery by hand.
+            //
+            //      The both-conditions guard is what keeps the 401 retry storm
+            //      from coming back, so it is preserved exactly; we only re-check
+            //      it over time instead of once. Bounded so a device that never
+            //      signs in doesn't poll forever.
             if (cfg.autoStartBlackBox !== false) {
-                setTimeout(() => {
-                    if (config?.agentUrl && (config?.authToken || p2pAuthToken)) {
-                        try {
-                            BlackBox_1.BlackBox.start();
-                        }
-                        catch (err) {
-                            console.warn('[YaverFeedback] BlackBox auto-start failed:', err);
-                        }
-                    }
-                }, 500);
+                YaverFeedback.scheduleBlackBoxAutoStart();
             }
         }
         // NOTE: We intentionally do NOT hook ErrorUtils.setGlobalHandler().
@@ -446,6 +599,41 @@ class YaverFeedback {
         //   - YaverFeedback.wrapErrorHandler(existingHandler) to create a
         //     pass-through wrapper they insert into their own error chain
     }
+    /**
+     * Opt-in global crash handler. This wraps the existing React Native
+     * ErrorUtils handler and still calls it, so Sentry/Crashlytics/Bugsnag can
+     * remain the system of record. The SDK only uploads a crash report and,
+     * when configured, asks the agent to create a fix task.
+     */
+    static installCrashHandler() {
+        if (crashHandlerInstalled)
+            return;
+        try {
+            const errorUtils = globalThis?.ErrorUtils;
+            if (!errorUtils?.getGlobalHandler || !errorUtils?.setGlobalHandler) {
+                return;
+            }
+            const next = errorUtils.getGlobalHandler();
+            errorUtils.setGlobalHandler((error, isFatal) => {
+                YaverFeedback.attachError(error, {
+                    source: 'global-handler',
+                    crashAware: true,
+                });
+                if (errorBuffer.length > 0) {
+                    errorBuffer[errorBuffer.length - 1].isFatal = isFatal ?? true;
+                }
+                void YaverFeedback.reportCrash(error, {
+                    isFatal: isFatal ?? true,
+                    source: 'global-handler',
+                });
+                next?.(error, isFatal);
+            });
+            crashHandlerInstalled = true;
+        }
+        catch (err) {
+            console.warn('[YaverFeedback] installCrashHandler failed:', err);
+        }
+    }
     /**
      * Run agent discovery in the background.
      * Called automatically from init() when no agentUrl is provided.
@@ -547,11 +735,64 @@ class YaverFeedback {
         else {
             await YaverFeedback.discoverAgent();
         }
+        // Signing in is the event the auto-start was waiting for. If its bounded
+        // retry already gave up (device left signed out past the window), this is
+        // what brings the command channel up without requiring an app restart.
+        if (config.autoStartBlackBox !== false && !BlackBox_1.BlackBox.isStreaming) {
+            YaverFeedback.scheduleBlackBoxAutoStart();
+        }
     }
     /** Returns true once the SDK has a session token it can use. */
     static isAuthed() {
         return Boolean(config?.authToken);
     }
+    /**
+     * On-device App Store screenshot capture (Engine 2). Walks the routes
+     * the host hands us, screenshots each, and uploads to the agent which
+     * runs the App Store Connect backend. agentUrl / authToken / relay
+     * password default to the SDK's resolved session; the host only has to
+     * supply a navigation ref + the ordered route list.
+     *
+     *   YaverFeedback.captureStoreScreenshots({
+     *     app: 'sfmg',
+     *     navigationRef,
+     *     routes: ['/(tabs)/dashboard', '/(tabs)/messages', '/(tabs)/clients'],
+     *     submit: true,
+     *   })
+     */
+    static async captureStoreScreenshots(opts) {
+        const agentUrl = opts.agentUrl ?? config?.agentUrl ?? '';
+        const authToken = opts.authToken ?? config?.authToken ?? p2pAuthToken ?? '';
+        const relayPassword = opts.relayPassword ?? p2pRelayPassword;
+        if (!agentUrl || !authToken) {
+            return {
+                ok: false,
+                captured: 0,
+                uploaded: 0,
+                message: 'YaverFeedback not connected to an agent — init() with agentUrl + authToken first.',
+            };
+        }
+        return (0, storeShots_1.captureStoreScreenshots)({ ...opts, agentUrl, authToken, relayPassword });
+    }
+    /**
+     * Let the mobile app / CLI kick THIS device into self-capturing. Registers
+     * a BlackBox command listener that fires captureStoreScreenshots when the
+     * agent pushes a `capture_store_shots` command (its `data` may override
+     * `submit` / `locale`). Returns an unsubscribe fn. Call once after init,
+     * passing the app's navigation ref + the routes to walk.
+     */
+    static enableStoreShotsOnCommand(opts) {
+        return BlackBox_1.BlackBox.onCommand((cmd) => {
+            if (cmd?.command !== 'capture_store_shots')
+                return;
+            const data = cmd.data ?? {};
+            void YaverFeedback.captureStoreScreenshots({
+                ...opts,
+                submit: typeof data.submit === 'boolean' ? data.submit : opts.submit,
+                locale: typeof data.locale === 'string' ? data.locale : opts.locale,
+            });
+        });
+    }
     /**
      * Request the embedded FeedbackModal to show the login screen. Works by
      * emitting an event the modal listens for — avoids forcing the host app
@@ -571,6 +812,25 @@ class YaverFeedback {
         const { DeviceEventEmitter } = require('react-native');
         DeviceEventEmitter.emit('yaverFeedback:startMachinePicker');
     }
+    /** Begin the reusable host-app Dogfood wizard. Owner OAuth and machine
+     * selection intentionally happen before installation enrollment/runtime
+     * controls because starting builds or runners is owner-level authority. */
+    static beginDogfoodOnboarding(options) {
+        dogfoodOnboarding = options;
+        if (!config)
+            YaverFeedback.init({ autoLogin: true });
+        if (!YaverFeedback.isAuthed()) {
+            YaverFeedback.showLogin();
+            return;
+        }
+        YaverFeedback.showMachinePicker();
+    }
+    static getDogfoodOnboarding() {
+        return dogfoodOnboarding;
+    }
+    static clearDogfoodOnboarding() {
+        dogfoodOnboarding = null;
+    }
     /**
      * Update the selected remote device. Resets the cached agent URL so the
      * next `startReport()` (or FloatingButton press) rediscovers against the
@@ -579,9 +839,19 @@ class YaverFeedback {
     static async setPreferredDevice(deviceId) {
         if (!config)
             return;
+        const wasUnified = !config.renderDeviceId
+            || config.renderDeviceId === config.codingDeviceId
+            || config.renderDeviceId === config.preferredDeviceId;
         config.preferredDeviceId = deviceId;
+        config.codingDeviceId = deviceId;
+        if (wasUnified)
+            config.renderDeviceId = deviceId;
         config.agentUrl = undefined;
+        config.codingAgentUrl = undefined;
+        if (wasUnified)
+            config.renderAgentUrl = undefined;
         p2pClient = null;
+        renderP2PClient = null;
         p2pAuthToken = null;
         await YaverFeedback.discoverAgent();
     }
@@ -591,8 +861,7 @@ class YaverFeedback {
             return null;
         const preferredDeviceId = config.preferredDeviceId;
         const devices = await (0, auth_1.listReachableDevices)(config.authToken);
-        const all = [...devices.owned, ...devices.shared];
-        return all.find((device) => device.deviceId === preferredDeviceId) ?? null;
+        return devices.owned.find((device) => device.deviceId === preferredDeviceId) ?? null;
     }
     /**
      * Trigger remote device-auth for a CLI runner on the selected agent
@@ -642,6 +911,7 @@ class YaverFeedback {
             config.agentUrl = undefined;
         }
         p2pClient = null;
+        renderP2PClient = null;
         p2pAuthToken = null;
     }
     /**
@@ -747,32 +1017,138 @@ class YaverFeedback {
             }
             BlackBox_1.BlackBox.unwrapConsole(); // ensure console is restored even if BlackBox wasn't started
             errorBuffer = [];
-            if (shakeDetector) {
-                shakeDetector.stop();
-                shakeDetector = null;
-            }
+            YaverFeedback.stopShakeDetector();
         }
         else {
             // === ENABLE ===
             if (blackBoxWasStreaming) {
                 BlackBox_1.BlackBox.start(); // restart with previous config
             }
-            // Restart shake detector if trigger is 'shake'
-            if (config?.trigger === 'shake' && !config?.disableShakeGesture && !shakeDetector) {
-                shakeDetector = new ShakeDetector_1.ShakeDetector();
-                shakeDetector.start(() => {
-                    YaverFeedback.notifyShake();
-                    if (config?.reportingOnly) {
-                        YaverFeedback.sendAutoReport();
-                    }
-                    else {
-                        YaverFeedback.startReport();
-                    }
-                });
-            }
+            enabled = true; // syncShakeDetector reads this
+            YaverFeedback.syncShakeDetector();
         }
         enabled = value;
     }
+    /**
+     * Turn shake-to-report on or off without tearing the SDK down.
+     *
+     * `trigger` is read only inside init(), so before this the only ways to
+     * stop listening for a shake were setEnabled(false) — which also kills the
+     * flight recorder and the agent command channel — or a re-init, which used
+     * to stack a duplicate command handler. Neither is what "turn the shake
+     * catcher off" should cost.
+     *
+     * Persists onto config.disableShakeGesture, so a later setEnabled(true)
+     * honours it rather than resurrecting the listener.
+     */
+    static setShakeEnabled(value) {
+        if (!config)
+            return;
+        config.disableShakeGesture = !value;
+        YaverFeedback.syncShakeDetector();
+    }
+    /** Whether the shake listener is currently armed. */
+    static isShakeEnabled() {
+        return shakeDetector !== null;
+    }
+    /**
+     * Bring the shake listener in line with the current config. Idempotent —
+     * safe to call whenever `enabled`, `trigger`, or `disableShakeGesture`
+     * moves.
+     */
+    static syncShakeDetector() {
+        const want = enabled && config?.trigger === 'shake' && !config?.disableShakeGesture;
+        if (want && !shakeDetector) {
+            shakeDetector = new ShakeDetector_1.ShakeDetector();
+            shakeDetector.start(() => {
+                YaverFeedback.notifyShake();
+                if (config?.reportingOnly) {
+                    YaverFeedback.sendAutoReport();
+                }
+                else {
+                    YaverFeedback.startReport();
+                }
+            });
+        }
+        else if (!want && shakeDetector) {
+            YaverFeedback.stopShakeDetector();
+        }
+    }
+    static stopShakeDetector() {
+        if (shakeDetector) {
+            shakeDetector.stop();
+            shakeDetector = null;
+        }
+    }
+    /** Cancel a pending BlackBox auto-start retry chain. */
+    static cancelBlackBoxAutoStart() {
+        if (autoStartTimer) {
+            clearTimeout(autoStartTimer);
+            autoStartTimer = null;
+        }
+    }
+    /**
+     * Start BlackBox as soon as we have BOTH an agentUrl and a token, polling
+     * until then.
+     *
+     * Both conditions are mandatory and deliberate: starting without a token
+     * makes the SSE channel 401 and retry with backoff, which is the tight
+     * string-concat + JSON-parse loop that used to SIGSEGV Hermes on iOS 18.3.1
+     * during Screenshot & Fix. This only re-checks that same guard over time.
+     *
+     * Bounded at ~60s: long enough for AsyncStorage hydration plus a Convex
+     * discovery round trip on a cold, off-LAN start, short enough that a device
+     * whose user never signs in stops polling. Giving up here costs nothing —
+     * setAuthToken() and startReport() both reschedule, so signing in later
+     * still brings the channel up.
+     */
+    static scheduleBlackBoxAutoStart(attempt = 0) {
+        const MAX_ATTEMPTS = 60;
+        const FIRST_DELAY_MS = 500;
+        const RETRY_DELAY_MS = 1000;
+        // Re-run discovery every Nth tick rather than every tick: it is a Convex
+        // round trip plus LAN probing, so once a second would hammer both. Every
+        // 3s is responsive enough that waking the dev machine reconnects the phone
+        // on its own, without the user wondering whether to restart the app.
+        const REDISCOVER_EVERY = 3;
+        YaverFeedback.cancelBlackBoxAutoStart();
+        if (!enabled || attempt >= MAX_ATTEMPTS)
+            return;
+        const timer = setTimeout(() => {
+            autoStartTimer = null;
+            // A destroy() or setEnabled(false) between scheduling and firing.
+            if (!enabled || !config)
+                return;
+            if (BlackBox_1.BlackBox.isStreaming)
+                return;
+            if (config.agentUrl && (config.authToken || p2pAuthToken)) {
+                try {
+                    // Pass the host's BlackBox config through. This used to call
+                    // start() bare, so a host that configured the flight recorder
+                    // — as the README itself shows — had it silently replaced by
+                    // defaults, and appName came out ''.
+                    BlackBox_1.BlackBox.start(config.blackBox);
+                }
+                catch (err) {
+                    console.warn('[YaverFeedback] BlackBox auto-start failed:', err);
+                }
+                return;
+            }
+            // No agent yet. Re-attempt discovery instead of only re-reading the
+            // flag: hydrateSession() runs discoverAgent() exactly once at init, so
+            // if the dev machine was unreachable at that moment — asleep, phone
+            // still on cellular before the relay came up, agent not yet serving —
+            // agentUrl stayed null for the whole process lifetime and only an app
+            // restart could recover it. discoverAgent() self-guards on "already
+            // have a URL" and "no token", so calling it again is cheap and safe.
+            if (!config.agentUrl && attempt > 0 && attempt % REDISCOVER_EVERY === 0) {
+                void YaverFeedback.discoverAgent();
+            }
+            YaverFeedback.scheduleBlackBoxAutoStart(attempt + 1);
+        }, attempt === 0 ? FIRST_DELAY_MS : RETRY_DELAY_MS);
+        autoStartTimer = timer;
+        unrefTimer(timer);
+    }
     /** Returns whether the SDK is currently enabled. */
     static isEnabled() {
         return enabled;
@@ -781,6 +1157,61 @@ class YaverFeedback {
     static getConfig() {
         return config;
     }
+    /** Current third-party SDK mode. Fails closed unless enabled + account match. */
+    static getDogfoodStatus() {
+        return (0, dogfoodPolicy_1.resolveSDKDogfood)(config?.dogfood);
+    }
+    /** One-call, account-free Dogfood bootstrap for third-party apps. On first
+     * launch it creates/proves the installation key and returns pending; after
+     * owner approval the same call obtains a short-lived scoped Yaver session
+     * and enables Dogfood UX without the host app implementing OAuth. */
+    static async enableDeviceDogfood(options) {
+        const client = new deviceDogfood_1.YaverDeviceDogfood(options);
+        let status = await client.status();
+        if (status === 'unregistered' || status === 'pending' || status === 'cancelled' || status === 'revoked' || status === 'superseded') {
+            const enrolled = status === 'unregistered' || status === 'pending'
+                ? await client.enroll(react_native_1.Platform.OS)
+                : await client.reRegister(react_native_1.Platform.OS);
+            status = enrolled.status;
+        }
+        const info = await client.enrollmentInfo();
+        const session = status === 'active' ? await client.session() : null;
+        if (!config)
+            YaverFeedback.init({ autoLogin: false });
+        if (config) {
+            config.dogfood = {
+                enabled: status === 'active' && !!session,
+                appId: options.appId,
+                installationId: info.installationId,
+                installationStatus: status === 'active' && session ? 'active' : status === 'unregistered' ? 'pending' : status,
+                label: options.label,
+            };
+            // A normal Yaver OAuth session remains authoritative for the runtime
+            // wizard. Only account-free hosts adopt the narrow installation token.
+            if (session && !config.authToken)
+                await YaverFeedback.setAuthToken(session.token);
+        }
+        try {
+            const { DeviceEventEmitter } = require('react-native');
+            DeviceEventEmitter.emit('yaverFeedback:dogfoodChanged', { active: !!session, status });
+        }
+        catch { /* noop */ }
+        return { status, installationId: info.installationId, session };
+    }
+    /** Confirmed by the Y badge/UI before this is called. Reverts this SDK to
+     * normal Feedback mode for the remainder of the app run. */
+    static async exitDogfoodMode() {
+        const cfg = config?.dogfood;
+        if (!cfg)
+            return;
+        cfg.enabled = false;
+        await cfg.onExit?.();
+        try {
+            const { DeviceEventEmitter } = require('react-native');
+            DeviceEventEmitter.emit('yaverFeedback:dogfoodChanged', { active: false, exited: true });
+        }
+        catch { /* noop */ }
+    }
     /** Returns the resolved relay password the SDK is currently using.
      *  Empty string when no relay routing is in play (direct LAN agent
      *  URLs need no password). Callers attaching it to relay-routed
@@ -843,6 +1274,104 @@ class YaverFeedback {
             next?.(error, isFatal);
         };
     }
+    /**
+     * Upload a crash-aware feedback bundle. Apps can call this from their own
+     * error boundary/global handler. If crashReporting.autoFix is true, the SDK
+     * also triggers the agent's feedback-fix task; reload delivery still happens
+     * through the existing BlackBox command stream.
+     */
+    static async reportCrash(error, opts) {
+        if (!config || !enabled || !config.crashReporting?.enabled)
+            return {};
+        if (crashReportInFlight)
+            return {};
+        crashReportInFlight = true;
+        try {
+            YaverFeedback.attachError(error, {
+                ...(config.crashReporting.metadata || {}),
+                ...(opts?.metadata || {}),
+                crashAware: true,
+            });
+            if (errorBuffer.length > 0) {
+                errorBuffer[errorBuffer.length - 1].isFatal = opts?.isFatal ?? true;
+            }
+            if (!config.agentUrl) {
+                await YaverFeedback.discoverAgent();
+            }
+            if (!config.agentUrl) {
+                console.warn('[YaverFeedback] No agent URL — cannot send crash report.');
+                return {};
+            }
+            const { Platform, Dimensions } = require('react-native');
+            const { uploadFeedback } = require('./upload');
+            const { width, height } = Dimensions.get('window');
+            let screenshotPath;
+            if (config.crashReporting.captureScreenshot !== false) {
+                try {
+                    const { captureScreenshot } = require('./capture');
+                    screenshotPath = await captureScreenshot();
+                }
+                catch { }
+            }
+            const autoFix = opts?.autoFix ?? config.crashReporting.autoFix === true;
+            const identity = (0, P2PClient_1.resolveReportIdentity)({
+                projectName: config?.projectName,
+                bundleId: config?.bundleId,
+                surface: config?.surface,
+                surfaces: config?.surfaces,
+                stack: config?.stack,
+                stacks: config?.stacks,
+                testSurfaces: config?.testSurfaces,
+                feedbackSdk: config?.feedbackSdk,
+                feedbackTransport: config?.feedbackTransport,
+                voiceCapabilities: config?.voiceCapabilities,
+                sttProvider: config?.sttProvider,
+                ttsProvider: config?.ttsProvider,
+            });
+            const bundle = {
+                metadata: {
+                    timestamp: new Date().toISOString(),
+                    reportKind: 'crash',
+                    deviceInfo: {
+                        platform: Platform.OS,
+                        osVersion: String(Platform.Version),
+                        model: Platform.OS === 'ios' ? 'iOS Device' : 'Android Device',
+                        screenWidth: width,
+                        screenHeight: height,
+                        appName: identity.appName,
+                    },
+                    app: identity.app,
+                    project: identity.project,
+                    userNote: '[Crash report]',
+                    crash: {
+                        message: error.message,
+                        isFatal: opts?.isFatal ?? true,
+                        source: opts?.source ?? 'manual',
+                        autoFixRequested: autoFix,
+                    },
+                },
+                screenshots: screenshotPath ? [screenshotPath] : [],
+                errors: errorBuffer.length > 0 ? [...errorBuffer] : undefined,
+            };
+            const uploaded = await uploadFeedback(config.agentUrl, config.authToken ?? '', bundle, p2pRelayPassword);
+            const reportId = uploaded?.id ??
+                uploaded?.reportId;
+            let taskId;
+            if (autoFix && reportId) {
+                const client = p2pClient ?? new P2PClient_1.P2PClient(config.agentUrl, config.authToken ?? '', p2pRelayPassword);
+                const fix = await client.triggerFix(reportId);
+                taskId = fix?.taskId;
+            }
+            return { reportId, taskId };
+        }
+        catch (err) {
+            console.warn('[YaverFeedback] Crash report failed:', err);
+            return {};
+        }
+        finally {
+            crashReportInFlight = false;
+        }
+    }
     /**
      * Returns the P2P client instance.
      * Available after init if agentUrl is set, or after first successful discovery.
@@ -850,6 +1379,16 @@ class YaverFeedback {
     static getP2PClient() {
         return p2pClient;
     }
+    /** Renderer/reload route; intentionally distinct from the coding client. */
+    static getRenderP2PClient() {
+        return renderP2PClient ?? p2pClient;
+    }
+    static getMachineRouting() {
+        return {
+            codingDeviceId: config?.codingDeviceId || config?.preferredDeviceId,
+            renderDeviceId: config?.renderDeviceId || config?.codingDeviceId || config?.preferredDeviceId,
+        };
+    }
     // ─── One-stop SaaS replacement methods ─────────────────────────
     //
     // These are the three solo-dev SaaS-replacement entry points
@@ -960,6 +1499,7 @@ class YaverFeedback {
                     config.agentUrl = result.url;
                     const rp = await resolveRelayPassword(config.authToken ?? '');
                     p2pClient = new P2PClient_1.P2PClient(result.url, config.authToken ?? '', rp);
+                    renderP2PClient = p2pClient;
                 }
             }
             catch { }
@@ -981,17 +1521,33 @@ class YaverFeedback {
             catch {
                 // Screenshot capture may fail (e.g. no view ref) — continue without it
             }
+            const identity = (0, P2PClient_1.resolveReportIdentity)({
+                projectName: config?.projectName,
+                bundleId: config?.bundleId,
+                surface: config?.surface,
+                surfaces: config?.surfaces,
+                stack: config?.stack,
+                stacks: config?.stacks,
+                testSurfaces: config?.testSurfaces,
+                feedbackSdk: config?.feedbackSdk,
+                feedbackTransport: config?.feedbackTransport,
+                voiceCapabilities: config?.voiceCapabilities,
+                sttProvider: config?.sttProvider,
+                ttsProvider: config?.ttsProvider,
+            });
             const bundle = {
                 metadata: {
                     timestamp: new Date().toISOString(),
-                    device: {
+                    deviceInfo: {
                         platform: Platform.OS,
                         osVersion: String(Platform.Version),
                         model: Platform.OS === 'ios' ? 'iOS Device' : 'Android Device',
                         screenWidth: width,
                         screenHeight: height,
+                        appName: identity.appName,
                     },
-                    app: {},
+                    app: identity.app,
+                    project: identity.project,
                     userNote: '[Auto-report via shake]',
                 },
                 screenshots: screenshotPath ? [screenshotPath] : [],
@@ -1143,10 +1699,22 @@ class YaverFeedback {
             shakeDetector.stop();
             shakeDetector = null;
         }
+        // Drop the agent command handler and un-monkey-patch console. Without
+        // these, destroy() left the SDK half-alive: console stayed wrapped, and
+        // the reload handler kept firing on a "destroyed" SDK — then a later
+        // init() stacked a second one on top.
+        commandUnsubscribe?.();
+        commandUnsubscribe = null;
+        // Before `enabled = false` / `config = null` below, so an in-flight retry
+        // can't fire against a torn-down config.
+        YaverFeedback.cancelBlackBoxAutoStart();
+        BlackBox_1.BlackBox.stop();
+        BlackBox_1.BlackBox.unwrapConsole();
         firstShakeFired = false;
         enabled = false;
         config = null;
         p2pClient = null;
+        renderP2PClient = null;
         errorBuffer = [];
     }
 }