yaver-feedback-react-native 0.6.1 → 0.7.1

package/dist/MachinePickerScreen.js

@@ -79,7 +79,11 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
     };
     const renderDevice = (device) => {
         const selected = device.deviceId === currentDeviceId;
-        const stale = Date.now() - device.lastHeartbeat > 60000;
+        // Match the Yaver mobile app: HEARTBEAT_STALE_MS is 90 s. Using
+        // 60 s here flashed yellow on a single missed agent beat even
+        // though the Mac was up.
+        const stale = device.lastHeartbeat > 0 &&
+            Date.now() - device.lastHeartbeat > 90000;
         const healthColor = !device.isOnline
             ? '#ef4444'
             : device.needsAuth || device.runnerDown || stale

package/dist/P2PClient.d.ts

@@ -68,6 +68,30 @@ export declare class P2PClient {
     reloadApp(mode?: 'dev' | 'bundle'): Promise<{
         ok: boolean;
     }>;
+    /**
+     * Open a vibing session on the connected agent. Vibing is the Yaver
+     * interactive coding-agent flow — `/vibing/execute` creates a task with
+     * the project context plus the user's prompt. Returns the task id the
+     * caller can poll via `/tasks/{id}` if needed.
+     *
+     * Requires an owner/CLI/paired token — the `/vibing*` routes do not
+     * currently accept SDK-minted tokens. Power users typically drive
+     * vibing from Claude Code / the Yaver mobile app; this method is a
+     * convenience for the SDK's one-tap bug-report-to-vibing path.
+     */
+    vibing(prompt: string, projectPath?: string): Promise<{
+        taskId: string;
+    }>;
+    /**
+     * After uploading a feedback bundle with `uploadFeedback`, call this
+     * with the returned report id to create a fix task on the agent. The
+     * task includes the feedback's screenshots, errors, and (when available)
+     * the BlackBox context for the originating device.
+     */
+    triggerFix(feedbackId: string): Promise<{
+        taskId: string;
+        prompt: string;
+    }>;
     /** Get the download URL for a build artifact. */
     getArtifactUrl(buildId: string): string;
     /**

package/dist/P2PClient.js

@@ -62,13 +62,6 @@ class P2PClient {
                 name: `screenshot_${i}.png`,
             });
         }
-        if (bundle.audio) {
-            formData.append('audio', {
-                uri: react_native_1.Platform.OS === 'android' ? `file://${bundle.audio}` : bundle.audio,
-                type: 'audio/m4a',
-                name: 'voice_note.m4a',
-            });
-        }
         if (bundle.video) {
             formData.append('video', {
                 uri: react_native_1.Platform.OS === 'android' ? `file://${bundle.video}` : bundle.video,
@@ -188,17 +181,79 @@ class P2PClient {
      * @param mode - "dev" for hot reload, "bundle" for native bundle rebuild
      */
     async reloadApp(mode = 'dev') {
-        const response = await fetch(`${this.baseUrl}/dev/reload-app`, {
+        // Primary path: /dev/reload — same endpoint the Yaver mobile app uses.
+        // Triggers Metro/Expo HMR synchronously and emits an SSE `reload` event
+        // on /dev/events that the FeedbackModal can subscribe to for progress.
+        //
+        // Only fall back to /dev/reload-app (the BlackBox-SSE-broadcast path)
+        // when the primary path reports "no dev server running" — that mode is
+        // really for the mobile app remotely kicking a third-party app, not
+        // for the app kicking itself.
+        const primary = await fetch(`${this.baseUrl}/dev/reload`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${this.authToken}` },
+        });
+        if (primary.ok) {
+            return primary.json().catch(() => ({ ok: true }));
+        }
+        if (primary.status >= 500 || primary.status === 404 || mode === 'bundle') {
+            const fallback = await fetch(`${this.baseUrl}/dev/reload-app`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ mode }),
+            });
+            if (!fallback.ok) {
+                const text = await fallback.text().catch(() => '');
+                throw new Error(`[P2PClient] Reload failed (${fallback.status}): ${text}`);
+            }
+            return fallback.json().catch(() => ({ ok: true }));
+        }
+        const text = await primary.text().catch(() => '');
+        throw new Error(`[P2PClient] Reload failed (${primary.status}): ${text}`);
+    }
+    /**
+     * Open a vibing session on the connected agent. Vibing is the Yaver
+     * interactive coding-agent flow — `/vibing/execute` creates a task with
+     * the project context plus the user's prompt. Returns the task id the
+     * caller can poll via `/tasks/{id}` if needed.
+     *
+     * Requires an owner/CLI/paired token — the `/vibing*` routes do not
+     * currently accept SDK-minted tokens. Power users typically drive
+     * vibing from Claude Code / the Yaver mobile app; this method is a
+     * convenience for the SDK's one-tap bug-report-to-vibing path.
+     */
+    async vibing(prompt, projectPath) {
+        const response = await fetch(`${this.baseUrl}/vibing/execute`, {
             method: 'POST',
             headers: {
                 Authorization: `Bearer ${this.authToken}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ mode }),
+            body: JSON.stringify({ prompt, projectPath: projectPath ?? '' }),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            throw new Error(`[P2PClient] Vibing failed (${response.status}): ${text}`);
+        }
+        return response.json();
+    }
+    /**
+     * After uploading a feedback bundle with `uploadFeedback`, call this
+     * with the returned report id to create a fix task on the agent. The
+     * task includes the feedback's screenshots, errors, and (when available)
+     * the BlackBox context for the originating device.
+     */
+    async triggerFix(feedbackId) {
+        const response = await fetch(`${this.baseUrl}/feedback/${encodeURIComponent(feedbackId)}/fix`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${this.authToken}` },
         });
         if (!response.ok) {
             const text = await response.text().catch(() => '');
-            throw new Error(`[P2PClient] Reload app failed (${response.status}): ${text}`);
+            throw new Error(`[P2PClient] Fix trigger failed (${response.status}): ${text}`);
         }
         return response.json();
     }

package/dist/YaverFeedback.d.ts

@@ -19,6 +19,16 @@ export declare class YaverFeedback {
      * Sets config.agentUrl and creates P2PClient on success.
      */
     static discoverAgent(): Promise<void>;
+    /**
+     * Force a fresh Convex lookup for the agent URL — ignoring any
+     * cached URL. Callers use this after a P2P request fails
+     * (connection refused / timeout) because the most common cause is
+     * the Mac's LAN IP rotating. Convex has the fresh one, so we
+     * re-query and probe `[quicHost, ...localIps]` in parallel.
+     *
+     * Returns true when a new URL was adopted.
+     */
+    static reconnect(): Promise<boolean>;
     /**
      * Pull a cached session token + selected device from AsyncStorage (populated
      * by the in-SDK login + machine-picker screens). When present the SDK can
@@ -116,10 +126,6 @@ export declare class YaverFeedback {
      * Available after init if agentUrl is set, or after first successful discovery.
      */
     static getP2PClient(): P2PClient | null;
-    /** Returns the current feedback mode. */
-    static getFeedbackMode(): 'live' | 'narrated' | 'batch';
-    /** Returns the agent commentary level (0-10). */
-    static getCommentaryLevel(): number;
     /**
      * Record a business event. Routes through BlackBox so the agent
      * persists it to the analytics ledger (no dashboards — export

package/dist/YaverFeedback.js

@@ -65,8 +65,6 @@ class YaverFeedback {
         config = {
             trigger: 'shake',
             maxRecordingDuration: 120,
-            feedbackMode: 'batch',
-            agentCommentaryLevel: 0,
             autoLogin: true,
             ...cfg,
         };
@@ -190,6 +188,36 @@ class YaverFeedback {
             // Discovery failed — FloatingButton will show disconnected, user can retry
         }
     }
+    /**
+     * Force a fresh Convex lookup for the agent URL — ignoring any
+     * cached URL. Callers use this after a P2P request fails
+     * (connection refused / timeout) because the most common cause is
+     * the Mac's LAN IP rotating. Convex has the fresh one, so we
+     * re-query and probe `[quicHost, ...localIps]` in parallel.
+     *
+     * Returns true when a new URL was adopted.
+     */
+    static async reconnect() {
+        if (!config || !enabled)
+            return false;
+        if (!config.authToken || !config.convexUrl)
+            return false;
+        try {
+            const result = await Discovery_1.YaverDiscovery.refreshFromConvex({
+                convexUrl: config.convexUrl,
+                authToken: config.authToken,
+                preferredDeviceId: config.preferredDeviceId,
+            });
+            if (!result)
+                return false;
+            config.agentUrl = result.url;
+            p2pClient = new P2PClient_1.P2PClient(result.url, config.authToken ?? '');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Pull a cached session token + selected device from AsyncStorage (populated
      * by the in-SDK login + machine-picker screens). When present the SDK can
@@ -464,14 +492,6 @@ class YaverFeedback {
     static getP2PClient() {
         return p2pClient;
     }
-    /** Returns the current feedback mode. */
-    static getFeedbackMode() {
-        return config?.feedbackMode ?? 'batch';
-    }
-    /** Returns the agent commentary level (0-10). */
-    static getCommentaryLevel() {
-        return config?.agentCommentaryLevel ?? 0;
-    }
     // ─── One-stop SaaS replacement methods ─────────────────────────
     //
     // These are the three solo-dev SaaS-replacement entry points

package/dist/__tests__/YaverFeedback.test.js

@@ -36,22 +36,18 @@ describe('YaverFeedback', () => {
             expect(cfg.agentUrl).toBe('http://localhost:18080');
             expect(cfg.trigger).toBe('shake');
             expect(cfg.maxRecordingDuration).toBe(120);
-            expect(cfg.feedbackMode).toBe('batch');
-            expect(cfg.agentCommentaryLevel).toBe(0);
         });
         it('respects user-provided values over defaults', () => {
             YaverFeedback_1.YaverFeedback.init({
                 authToken: 'tok',
                 trigger: 'floating-button',
                 maxRecordingDuration: 60,
-                feedbackMode: 'live',
-                agentCommentaryLevel: 7,
+                strictNativeAuth: true,
             });
             const cfg = YaverFeedback_1.YaverFeedback.getConfig();
             expect(cfg.trigger).toBe('floating-button');
             expect(cfg.maxRecordingDuration).toBe(60);
-            expect(cfg.feedbackMode).toBe('live');
-            expect(cfg.agentCommentaryLevel).toBe(7);
+            expect(cfg.strictNativeAuth).toBe(true);
         });
         it('with enabled=false sets enabled to false', () => {
             YaverFeedback_1.YaverFeedback.init({
@@ -110,35 +106,6 @@ describe('YaverFeedback', () => {
             expect(cfg.agentUrl).toBe('http://10.0.0.1:18080');
         });
     });
-    describe('getFeedbackMode()', () => {
-        it('defaults to batch when no config', () => {
-            // After any init, feedbackMode defaults to 'batch'
-            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok' });
-            expect(YaverFeedback_1.YaverFeedback.getFeedbackMode()).toBe('batch');
-        });
-        it('returns configured mode', () => {
-            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', feedbackMode: 'narrated' });
-            expect(YaverFeedback_1.YaverFeedback.getFeedbackMode()).toBe('narrated');
-        });
-        it('returns live when configured', () => {
-            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', feedbackMode: 'live' });
-            expect(YaverFeedback_1.YaverFeedback.getFeedbackMode()).toBe('live');
-        });
-    });
-    describe('getCommentaryLevel()', () => {
-        it('defaults to 0', () => {
-            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok' });
-            expect(YaverFeedback_1.YaverFeedback.getCommentaryLevel()).toBe(0);
-        });
-        it('returns configured level', () => {
-            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', agentCommentaryLevel: 5 });
-            expect(YaverFeedback_1.YaverFeedback.getCommentaryLevel()).toBe(5);
-        });
-        it('returns max level when set to 10', () => {
-            YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', agentCommentaryLevel: 10 });
-            expect(YaverFeedback_1.YaverFeedback.getCommentaryLevel()).toBe(10);
-        });
-    });
     describe('startReport()', () => {
         it('does nothing when not enabled', async () => {
             YaverFeedback_1.YaverFeedback.init({ authToken: 'tok', enabled: false });

package/dist/__tests__/types.test.js

@@ -11,8 +11,6 @@ describe('React Native SDK types', () => {
             expect(config.trigger).toBeUndefined();
             expect(config.enabled).toBeUndefined();
             expect(config.maxRecordingDuration).toBeUndefined();
-            expect(config.feedbackMode).toBeUndefined();
-            expect(config.agentCommentaryLevel).toBeUndefined();
         });
         it('can be constructed with all optional fields', () => {
             const config = {
@@ -21,12 +19,10 @@ describe('React Native SDK types', () => {
                 trigger: 'shake',
                 enabled: true,
                 maxRecordingDuration: 60,
-                feedbackMode: 'live',
-                agentCommentaryLevel: 7,
+                strictNativeAuth: true,
             };
             expect(config.trigger).toBe('shake');
-            expect(config.feedbackMode).toBe('live');
-            expect(config.agentCommentaryLevel).toBe(7);
+            expect(config.strictNativeAuth).toBe(true);
         });
         it('accepts all trigger types', () => {
             const triggers = ['shake', 'floating-button', 'manual'];
@@ -35,13 +31,6 @@ describe('React Native SDK types', () => {
                 expect(config.trigger).toBe(trigger);
             });
         });
-        it('accepts all feedback modes', () => {
-            const modes = ['live', 'narrated', 'batch'];
-            modes.forEach((mode) => {
-                const config = { authToken: 'tok', feedbackMode: mode };
-                expect(config.feedbackMode).toBe(mode);
-            });
-        });
     });
     describe('FeedbackBundle', () => {
         it('can be constructed with required fields', () => {
@@ -67,9 +56,8 @@ describe('React Native SDK types', () => {
             expect(bundle.metadata.device.platform).toBe('ios');
             expect(bundle.screenshots).toEqual([]);
             expect(bundle.video).toBeUndefined();
-            expect(bundle.audio).toBeUndefined();
         });
-        it('can include optional video, audio, and screenshots', () => {
+        it('can include optional video + screenshots', () => {
             const bundle = {
                 metadata: {
                     timestamp: '2026-03-24T12:00:00Z',
@@ -84,11 +72,9 @@ describe('React Native SDK types', () => {
                     userNote: 'This button does not work',
                 },
                 video: '/tmp/recording.mp4',
-                audio: '/tmp/voice.m4a',
                 screenshots: ['/tmp/ss1.png', '/tmp/ss2.png'],
             };
             expect(bundle.video).toBe('/tmp/recording.mp4');
-            expect(bundle.audio).toBe('/tmp/voice.m4a');
             expect(bundle.screenshots).toHaveLength(2);
             expect(bundle.metadata.userNote).toBe('This button does not work');
         });
@@ -187,24 +173,6 @@ describe('React Native SDK types', () => {
             });
         });
     });
-    describe('AgentCommentary', () => {
-        it('has correct structure', () => {
-            const commentary = {
-                id: 'cmt-1',
-                timestamp: '2026-03-24T12:00:00Z',
-                message: 'I see a layout issue on the login screen',
-                type: 'observation',
-            };
-            expect(commentary.type).toBe('observation');
-        });
-        it('accepts all commentary types', () => {
-            const types = ['observation', 'suggestion', 'question', 'action'];
-            types.forEach((type) => {
-                const c = { id: '1', timestamp: 'now', message: 'test', type };
-                expect(c.type).toBe(type);
-            });
-        });
-    });
     describe('FeedbackStreamEvent', () => {
         it('has correct structure', () => {
             const event = {

package/dist/auth.d.ts

@@ -105,7 +105,17 @@ export interface RemoteDevice {
     accessScope: 'owner' | 'shared-scoped' | 'shared-legacy';
     quicHost: string;
     quicPort: number;
+    /** Agent HTTP port — preferred over quicPort when present. */
+    httpPort?: number;
     publicKey?: string;
+    /** Hardware identifier — used for dedup across re-pair events. */
+    hwid?: string;
+    /**
+     * Every LAN IP the agent reported in its last heartbeat. Useful on
+     * multi-homed hosts — probing all of them in parallel is the same
+     * trick the Yaver mobile app uses to "just work" on the same Wi-Fi.
+     */
+    localIps?: string[];
 }
 export interface DeviceList {
     owned: RemoteDevice[];
@@ -114,5 +124,9 @@ export interface DeviceList {
 /**
  * Fetch the set of remote dev machines this user can reach. Splits into
  * owned (user is the host) vs shared (host invited them as a guest).
+ *
+ * Collapses duplicate rows before splitting — Convex can return multiple
+ * rows per physical machine after a re-pair or hostname change, and the
+ * raw list used to render as "Kvancs-MacBook-Air.local ×3" in the picker.
  */
 export declare function listReachableDevices(token: string): Promise<DeviceList>;

package/dist/auth.js

@@ -346,6 +346,10 @@ async function loginWithEmail(email, password) {
 /**
  * Fetch the set of remote dev machines this user can reach. Splits into
  * owned (user is the host) vs shared (host invited them as a guest).
+ *
+ * Collapses duplicate rows before splitting — Convex can return multiple
+ * rows per physical machine after a re-pair or hostname change, and the
+ * raw list used to render as "Kvancs-MacBook-Air.local ×3" in the picker.
  */
 async function listReachableDevices(token) {
     try {
@@ -355,10 +359,39 @@ async function listReachableDevices(token) {
         if (!res.ok)
             return { owned: [], shared: [] };
         const data = await res.json();
-        const all = (data.devices ?? []);
+        const raw = (data.devices ?? []);
+        // Normalise Convex field names → SDK's RemoteDevice shape. The
+        // backend returns `localIps`, sometimes the mobile-side mapping
+        // surfaces `lanIps` — accept either so the field survives.
+        const normalised = raw.map((d) => ({
+            deviceId: d.deviceId ?? d.id,
+            name: d.name ?? '',
+            platform: d.platform ?? d.os ?? '',
+            isOnline: !!d.isOnline,
+            needsAuth: !!d.needsAuth,
+            runnerDown: !!d.runnerDown,
+            lastHeartbeat: d.lastHeartbeat ?? 0,
+            isGuest: !!d.isGuest,
+            hostName: d.hostName,
+            hostEmail: d.hostEmail,
+            accessScope: d.accessScope ?? 'owner',
+            quicHost: d.quicHost ?? d.host ?? '',
+            quicPort: d.quicPort ?? 0,
+            httpPort: d.httpPort ?? d.quicPort,
+            publicKey: d.publicKey,
+            hwid: d.hardwareId ?? d.hwid,
+            localIps: Array.isArray(d.localIps)
+                ? d.localIps
+                : Array.isArray(d.lanIps)
+                    ? d.lanIps
+                    : undefined,
+        }));
+        // Lazy require so Jest + tree-shakers don't choke on a circular import.
+        const { collapseRemoteDevices } = require('./deviceDedup');
+        const deduped = collapseRemoteDevices(normalised);
         return {
-            owned: all.filter((d) => !d.isGuest),
-            shared: all.filter((d) => d.isGuest),
+            owned: deduped.filter((d) => !d.isGuest),
+            shared: deduped.filter((d) => d.isGuest),
         };
     }
     catch {

package/dist/capture.d.ts

@@ -1,27 +1,40 @@
 /**
- * Screen capture and audio recording helpers.
+ * Screen capture helpers — screenshot + video recording.
  *
- * Screenshot capture requires `react-native-view-shot` as a peer dependency.
- * Audio recording requires `react-native-audio-recorder-player` or a
- * similar library — the implementation below uses a minimal approach
- * that works when one of those is available.
+ * Peer deps (all optional — loaded lazily):
+ *   - `react-native-view-shot`        — screenshot
+ *   - `react-native-record-screen`    — video recording (iOS ReplayKit /
+ *                                       Android MediaProjection)
+ *
+ * Each helper surfaces a clear error if the module is missing so a host
+ * app knows exactly which peer dep to add. Audio-note / voice-command
+ * recording was removed in 0.7.0 — see FeedbackModal for the new
+ * 5-button surface.
  */
 /**
  * Capture the current screen as a PNG image.
  * Requires `react-native-view-shot` to be installed.
- * @returns File path of the captured screenshot.
+ *
+ * Note: the feedback modal should hide itself *before* calling this so the
+ * screenshot contains the underlying app state (the actual bug), not the
+ * modal. See `FeedbackModal.handleScreenshotForFix`.
  */
 export declare function captureScreenshot(): Promise<string>;
 /**
- * Start recording an audio voice note.
- * Requires `react-native-audio-recorder-player` to be installed.
+ * Start a screen-recording session. Requires
+ * `react-native-record-screen` as a peer dep.
+ *
+ * The user must grant the iOS ReplayKit / Android MediaProjection
+ * permission the first time; the prompt is shown by the native module,
+ * not the SDK.
  */
-export declare function startAudioRecording(): Promise<void>;
+export declare function startVideoRecording(): Promise<void>;
 /**
- * Stop the current audio recording.
- * @returns Object with the file path and duration in seconds.
+ * Stop the current video recording and return the on-device file path.
  */
-export declare function stopAudioRecording(): Promise<{
+export declare function stopVideoRecording(): Promise<{
     path: string;
     duration: number;
 }>;
+/** Whether a video recording is currently active. */
+export declare function isVideoRecording(): boolean;

package/dist/capture.js

@@ -1,21 +1,29 @@
 "use strict";
 /**
- * Screen capture and audio recording helpers.
+ * Screen capture helpers — screenshot + video recording.
  *
- * Screenshot capture requires `react-native-view-shot` as a peer dependency.
- * Audio recording requires `react-native-audio-recorder-player` or a
- * similar library — the implementation below uses a minimal approach
- * that works when one of those is available.
+ * Peer deps (all optional — loaded lazily):
+ *   - `react-native-view-shot`        — screenshot
+ *   - `react-native-record-screen`    — video recording (iOS ReplayKit /
+ *                                       Android MediaProjection)
+ *
+ * Each helper surfaces a clear error if the module is missing so a host
+ * app knows exactly which peer dep to add. Audio-note / voice-command
+ * recording was removed in 0.7.0 — see FeedbackModal for the new
+ * 5-button surface.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.captureScreenshot = captureScreenshot;
-exports.startAudioRecording = startAudioRecording;
-exports.stopAudioRecording = stopAudioRecording;
-let audioRecorderModule = null;
+exports.startVideoRecording = startVideoRecording;
+exports.stopVideoRecording = stopVideoRecording;
+exports.isVideoRecording = isVideoRecording;
 /**
  * Capture the current screen as a PNG image.
  * Requires `react-native-view-shot` to be installed.
- * @returns File path of the captured screenshot.
+ *
+ * Note: the feedback modal should hide itself *before* calling this so the
+ * screenshot contains the underlying app state (the actual bug), not the
+ * modal. See `FeedbackModal.handleScreenshotForFix`.
  */
 async function captureScreenshot() {
     try {
@@ -27,48 +35,79 @@ async function captureScreenshot() {
         return uri;
     }
     catch (err) {
-        throw new Error('[YaverFeedback] Screenshot capture failed. Make sure react-native-view-shot is installed. ' +
+        throw new Error('[YaverFeedback] Screenshot capture failed. Install react-native-view-shot as a peer dep. ' +
             String(err));
     }
 }
+let videoRecorderModule = null;
+let videoRecordingActive = false;
 /**
- * Start recording an audio voice note.
- * Requires `react-native-audio-recorder-player` to be installed.
+ * Start a screen-recording session. Requires
+ * `react-native-record-screen` as a peer dep.
+ *
+ * The user must grant the iOS ReplayKit / Android MediaProjection
+ * permission the first time; the prompt is shown by the native module,
+ * not the SDK.
  */
-async function startAudioRecording() {
+async function startVideoRecording() {
+    if (videoRecordingActive) {
+        throw new Error('[YaverFeedback] A video recording is already in progress.');
+    }
     try {
-        const AudioRecorderPlayer = require('react-native-audio-recorder-player').default;
-        audioRecorderModule = new AudioRecorderPlayer();
-        await audioRecorderModule.startRecorder();
+        videoRecorderModule = require('react-native-record-screen').default ??
+            require('react-native-record-screen');
+        if (typeof videoRecorderModule.startRecording !== 'function') {
+            throw new Error('react-native-record-screen missing startRecording()');
+        }
+        const result = await videoRecorderModule.startRecording({
+            mic: false,
+            width: 720,
+            bitrate: 1024 * 1000,
+        });
+        if (result && result.status && result.status !== 'success') {
+            throw new Error(`startRecording returned ${result.status}`);
+        }
+        videoRecordingActive = true;
     }
     catch (err) {
-        audioRecorderModule = null;
-        throw new Error('[YaverFeedback] Audio recording failed to start. Make sure react-native-audio-recorder-player is installed. ' +
+        videoRecorderModule = null;
+        videoRecordingActive = false;
+        throw new Error('[YaverFeedback] Could not start screen recording. Install react-native-record-screen. ' +
             String(err));
     }
 }
 /**
- * Stop the current audio recording.
- * @returns Object with the file path and duration in seconds.
+ * Stop the current video recording and return the on-device file path.
  */
-async function stopAudioRecording() {
-    if (!audioRecorderModule) {
-        throw new Error('[YaverFeedback] No audio recording in progress.');
+async function stopVideoRecording() {
+    if (!videoRecordingActive || !videoRecorderModule) {
+        throw new Error('[YaverFeedback] No video recording in progress.');
     }
     try {
-        const result = await audioRecorderModule.stopRecorder();
-        const recorder = audioRecorderModule;
-        audioRecorderModule = null;
-        // result is the file path on most implementations
-        const path = typeof result === 'string' ? result : result?.uri ?? '';
-        // Duration tracking — recorder-player provides currentPosition in ms
-        const durationMs = typeof recorder.currentPosition === 'number'
-            ? recorder.currentPosition
-            : 0;
+        const res = await videoRecorderModule.stopRecording();
+        videoRecordingActive = false;
+        const path = typeof res === 'string'
+            ? res
+            : res?.result?.outputURL ??
+                res?.outputURL ??
+                res?.uri ??
+                '';
+        const durationMs = typeof res?.result?.duration === 'number'
+            ? res.result.duration
+            : typeof res?.duration === 'number'
+                ? res.duration
+                : 0;
+        if (!path) {
+            throw new Error('stopRecording() returned no file path');
+        }
         return { path, duration: durationMs / 1000 };
     }
     catch (err) {
-        audioRecorderModule = null;
-        throw new Error('[YaverFeedback] Failed to stop audio recording. ' + String(err));
+        videoRecordingActive = false;
+        throw new Error('[YaverFeedback] Failed to stop screen recording. ' + String(err));
     }
 }
+/** Whether a video recording is currently active. */
+function isVideoRecording() {
+    return videoRecordingActive;
+}