yaver-feedback-react-native 0.8.13 → 0.9.2

package/dist/__tests__/ShakeToggle.test.js

@@ -0,0 +1,121 @@
+"use strict";
+// Runtime shake toggling + init() idempotency.
+//
+// Host apps put the feedback SDK behind a settings switch, which means init /
+// enable / disable run repeatedly in one process. Two things used to break
+// there:
+//
+//   1. There was no way to turn the shake catcher off short of
+//      setEnabled(false) (which also stops the flight recorder and the agent
+//      command channel) or a full re-init. `trigger` is only read inside
+//      init(). setShakeEnabled() fills that gap.
+//
+//   2. init() registered a BlackBox command handler and threw away the
+//      unsubscribe, so each re-init stacked another. Two inits meant two
+//      reloads per agent command; destroy() never cleared them either.
+Object.defineProperty(exports, "__esModule", { value: true });
+const YaverFeedback_1 = require("../YaverFeedback");
+const BlackBox_1 = require("../BlackBox");
+const mockShakeStart = jest.fn();
+const mockShakeStop = jest.fn();
+jest.mock('../ShakeDetector', () => ({
+    ShakeDetector: jest.fn().mockImplementation(() => ({
+        start: mockShakeStart,
+        stop: mockShakeStop,
+    })),
+}));
+jest.mock('react-native', () => ({
+    Platform: { OS: 'ios' },
+    DeviceEventEmitter: { emit: jest.fn(), addListener: jest.fn() },
+    NativeModules: {},
+}));
+const mockFetch = jest.fn(() => Promise.resolve({ ok: true, json: () => Promise.resolve({}) }));
+global.fetch = mockFetch;
+beforeEach(() => {
+    jest.clearAllMocks();
+    YaverFeedback_1.YaverFeedback.destroy();
+});
+afterEach(() => {
+    YaverFeedback_1.YaverFeedback.destroy();
+});
+describe('setShakeEnabled', () => {
+    it('arms the shake listener on init when trigger is shake', () => {
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' });
+        expect(YaverFeedback_1.YaverFeedback.isShakeEnabled()).toBe(true);
+    });
+    it('disarms the listener without disabling the SDK', () => {
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' });
+        YaverFeedback_1.YaverFeedback.setShakeEnabled(false);
+        expect(YaverFeedback_1.YaverFeedback.isShakeEnabled()).toBe(false);
+        expect(mockShakeStop).toHaveBeenCalled();
+        // The point of a separate toggle: the rest of the SDK stays up.
+        expect(YaverFeedback_1.YaverFeedback.isEnabled()).toBe(true);
+    });
+    it('re-arms the listener', () => {
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' });
+        YaverFeedback_1.YaverFeedback.setShakeEnabled(false);
+        YaverFeedback_1.YaverFeedback.setShakeEnabled(true);
+        expect(YaverFeedback_1.YaverFeedback.isShakeEnabled()).toBe(true);
+    });
+    it('is idempotent — repeated calls do not stack detectors', () => {
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' });
+        mockShakeStart.mockClear();
+        YaverFeedback_1.YaverFeedback.setShakeEnabled(true);
+        YaverFeedback_1.YaverFeedback.setShakeEnabled(true);
+        expect(mockShakeStart).not.toHaveBeenCalled();
+        expect(YaverFeedback_1.YaverFeedback.isShakeEnabled()).toBe(true);
+    });
+    it('persists onto config so a later enable does not resurrect the listener', () => {
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' });
+        YaverFeedback_1.YaverFeedback.setShakeEnabled(false);
+        YaverFeedback_1.YaverFeedback.setEnabled(false);
+        YaverFeedback_1.YaverFeedback.setEnabled(true);
+        // The user said no shake. Cycling the master switch must not undo that.
+        expect(YaverFeedback_1.YaverFeedback.isShakeEnabled()).toBe(false);
+        expect(YaverFeedback_1.YaverFeedback.getConfig()?.disableShakeGesture).toBe(true);
+    });
+    it('does not arm the listener for a non-shake trigger', () => {
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'manual', agentUrl: 'http://x:18080', authToken: 't' });
+        expect(YaverFeedback_1.YaverFeedback.isShakeEnabled()).toBe(false);
+        YaverFeedback_1.YaverFeedback.setShakeEnabled(true);
+        expect(YaverFeedback_1.YaverFeedback.isShakeEnabled()).toBe(false);
+    });
+    it('no-ops before init rather than throwing', () => {
+        expect(() => YaverFeedback_1.YaverFeedback.setShakeEnabled(true)).not.toThrow();
+        expect(YaverFeedback_1.YaverFeedback.isShakeEnabled()).toBe(false);
+    });
+});
+describe('init() command-handler registration', () => {
+    it('does not stack command handlers across re-inits', () => {
+        const cfg = { trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' };
+        YaverFeedback_1.YaverFeedback.init(cfg);
+        YaverFeedback_1.YaverFeedback.init(cfg);
+        YaverFeedback_1.YaverFeedback.init(cfg);
+        // Three inits, one live handler. Before the fix this array grew by one
+        // each time, so a single agent 'reload' fired three reloads.
+        expect(BlackBox_1.BlackBox.commandHandlers.length).toBe(1);
+    });
+    it('fires a reload exactly once per command after repeated inits', () => {
+        // The user-visible symptom the count above stands in for.
+        const onReload = jest.fn();
+        const cfg = { trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't', onReload };
+        YaverFeedback_1.YaverFeedback.init(cfg);
+        YaverFeedback_1.YaverFeedback.init(cfg);
+        for (const h of BlackBox_1.BlackBox.commandHandlers)
+            h({ command: 'reload' });
+        expect(onReload).toHaveBeenCalledTimes(1);
+    });
+    it('destroy() unregisters the command handler', () => {
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' });
+        const before = BlackBox_1.BlackBox.commandHandlers.length;
+        expect(before).toBeGreaterThan(0);
+        YaverFeedback_1.YaverFeedback.destroy();
+        expect(BlackBox_1.BlackBox.commandHandlers.length).toBe(before - 1);
+    });
+    it('destroy() then init() leaves exactly one handler', () => {
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' });
+        YaverFeedback_1.YaverFeedback.destroy();
+        YaverFeedback_1.YaverFeedback.init({ trigger: 'shake', agentUrl: 'http://x:18080', authToken: 't' });
+        expect(BlackBox_1.BlackBox.commandHandlers.length).toBe(1);
+    });
+});

package/dist/__tests__/pickTargetDevice.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/pickTargetDevice.test.js

@@ -0,0 +1,89 @@
+"use strict";
+// Target-device selection contract.
+//
+// This exists because pickTargetDevice used to silently reroute: when the
+// user's `preferredDeviceId` was absent from the list — or present but
+// carrying an empty `quicHost` — the preference block fell through to the
+// generic "first fresh machine" search. The user picked their Mac mini and
+// the fix landed on their laptop, with no error on either end.
+//
+// The contract now: an explicit preference is honoured by id alone, or the
+// pick fails. Not connecting is a better failure than connecting to the
+// wrong host.
+Object.defineProperty(exports, "__esModule", { value: true });
+const device_1 = require("../_core/device");
+const constants_1 = require("../_core/constants");
+const NOW = 1700000000000;
+function device(over) {
+    return {
+        name: over.deviceId,
+        platform: 'darwin',
+        isOnline: true,
+        lastHeartbeat: NOW,
+        quicHost: '100.64.0.1',
+        quicPort: 18080,
+        ...over,
+    };
+}
+beforeEach(() => {
+    jest.spyOn(Date, 'now').mockReturnValue(NOW);
+});
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+describe('pickTargetDevice — explicit preference', () => {
+    it('returns the preferred device when it is fresh', () => {
+        const macmini = device({ deviceId: 'macmini' });
+        const laptop = device({ deviceId: 'laptop' });
+        expect((0, device_1.pickTargetDevice)([laptop, macmini], 'macmini')).toBe(macmini);
+    });
+    it('returns the preferred device even when it is STALE, rather than rerouting', () => {
+        const macmini = device({
+            deviceId: 'macmini',
+            lastHeartbeat: NOW - (constants_1.HEARTBEAT_STALE_MS + 1),
+        });
+        const laptop = device({ deviceId: 'laptop' });
+        expect((0, device_1.isDeviceFresh)(macmini)).toBe(false);
+        expect((0, device_1.pickTargetDevice)([laptop, macmini], 'macmini')).toBe(macmini);
+    });
+    it('returns the preferred device even with NO quicHost — relay addresses it by id', () => {
+        // This is the off-LAN shape: no LAN address is published, and the relay
+        // route is `<relay>/d/<deviceId>`. An empty quicHost is not a reason to
+        // reroute; it is the normal remote case.
+        const macmini = device({ deviceId: 'macmini', quicHost: '' });
+        const laptop = device({ deviceId: 'laptop' });
+        expect((0, device_1.pickTargetDevice)([laptop, macmini], 'macmini')).toBe(macmini);
+    });
+    it('returns null when the preferred id is absent — never falls through to another machine', () => {
+        const laptop = device({ deviceId: 'laptop' });
+        const desktop = device({ deviceId: 'desktop' });
+        expect((0, device_1.pickTargetDevice)([laptop, desktop], 'macmini')).toBeNull();
+    });
+    it('returns null for an unknown preference even when exactly one healthy machine exists', () => {
+        // The tempting "well, there's only one, just use it" case. Still wrong:
+        // the user asked for a specific host.
+        expect((0, device_1.pickTargetDevice)([device({ deviceId: 'laptop' })], 'macmini')).toBeNull();
+    });
+});
+describe('pickTargetDevice — no preference', () => {
+    it('prefers a fresh device with a quicHost over a stale one', () => {
+        const stale = device({
+            deviceId: 'stale',
+            lastHeartbeat: NOW - (constants_1.HEARTBEAT_STALE_MS + 1),
+        });
+        const fresh = device({ deviceId: 'fresh' });
+        expect((0, device_1.pickTargetDevice)([stale, fresh])).toBe(fresh);
+    });
+    it('falls back to an online device with a quicHost when none are fresh', () => {
+        const offline = device({ deviceId: 'offline', isOnline: false });
+        const online = device({
+            deviceId: 'online',
+            lastHeartbeat: NOW - (constants_1.HEARTBEAT_STALE_MS + 1),
+        });
+        expect((0, device_1.pickTargetDevice)([offline, online])).toBe(online);
+    });
+    it('returns null for an empty list', () => {
+        expect((0, device_1.pickTargetDevice)([], 'macmini')).toBeNull();
+        expect((0, device_1.pickTargetDevice)([])).toBeNull();
+    });
+});

package/dist/__tests__/reloadActions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/reloadActions.test.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const reloadActions_1 = require("../reloadActions");
+const DEV = { isDevBuild: true, connected: true };
+describe('reloadActions — the production guard', () => {
+    // THIS IS THE GUARD. Prove it by breaking it: flip `if (!opts.isDevBuild)`
+    // in reloadActions.ts to `if (opts.isDevBuild)` and this test fails while
+    // every other test in this file still passes.
+    it('returns NOTHING in a production build, even with a healthy dev server', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: true, framework: 'vite' }, { isDevBuild: false, connected: true, includeRebuild: true });
+        expect(actions).toEqual([]);
+    });
+    it('returns actions in a dev build', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: true, framework: 'vite' }, DEV);
+        expect(actions.map((a) => a.id)).toEqual(['hot', 'full']);
+        expect(actions.every((a) => a.enabled)).toBe(true);
+    });
+});
+describe('reloadFrameworkFamily', () => {
+    it.each([
+        ['flutter', 'flutter'],
+        ['expo', 'react-native'],
+        ['react-native', 'react-native'],
+        ['vite', 'web'],
+        ['nextjs', 'web'],
+        ['', 'unknown'],
+        ['godot', 'unknown'],
+    ])('maps %s → %s', (framework, family) => {
+        expect((0, reloadActions_1.reloadFrameworkFamily)(framework)).toBe(family);
+    });
+});
+describe('per-stack labels', () => {
+    it('calls the full action a Hot Restart on Flutter (stdin R), not a Full Reload', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: true, framework: 'flutter' }, DEV);
+        expect(actions.find((a) => a.id === 'hot').label).toBe('Hot Reload');
+        expect(actions.find((a) => a.id === 'full').label).toBe('Hot Restart');
+        expect(actions.find((a) => a.id === 'full').hint).toContain('(R)');
+    });
+    it('calls it a Full Reload everywhere else', () => {
+        for (const framework of ['expo', 'vite', 'nextjs']) {
+            const actions = (0, reloadActions_1.reloadActions)({ running: true, framework }, DEV);
+            expect(actions.find((a) => a.id === 'full').label).toBe('Full Reload');
+        }
+    });
+});
+describe('URL / payload construction', () => {
+    it('sends fast for hot and full for full, both to /dev/reload', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: true, framework: 'flutter' }, DEV);
+        expect((0, reloadActions_1.reloadRequest)(actions[0])).toEqual({
+            method: 'POST',
+            path: reloadActions_1.RELOAD_PATH,
+            body: { mode: 'fast' },
+        });
+        expect((0, reloadActions_1.reloadRequest)(actions[1])).toEqual({
+            method: 'POST',
+            path: reloadActions_1.RELOAD_PATH,
+            body: { mode: 'full' },
+        });
+    });
+    it('routes the RN bundle rebuild to /dev/reload-app', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: false }, { ...DEV, includeRebuild: true });
+        const rebuild = actions.find((a) => a.id === 'rebuild');
+        expect((0, reloadActions_1.reloadRequest)(rebuild)).toEqual({
+            method: 'POST',
+            path: reloadActions_1.RELOAD_APP_PATH,
+            body: { mode: 'bundle' },
+        });
+    });
+});
+describe('a blocked action NAMES the blocker', () => {
+    it('names the missing dev server and the command that starts it', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: false }, { ...DEV, machineLabel: 'primary' });
+        expect(actions).toHaveLength(2);
+        for (const action of actions) {
+            expect(action.enabled).toBe(false);
+            expect(action.disabledReason).toContain('primary');
+            expect(action.disabledReason).toContain('yaver dev start');
+        }
+    });
+    it('names "still building" rather than pretending nothing is running', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: true, building: true, framework: 'expo' }, DEV);
+        expect(actions[0].disabledReason).toContain('still building');
+    });
+    it('names the missing machine when disconnected', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: true, framework: 'expo' }, { isDevBuild: true, connected: false });
+        expect(actions[0].disabledReason).toContain('Not connected');
+    });
+    it('keeps Rebuild Bundle ENABLED with no dev server — that is its whole point', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: false }, { ...DEV, includeRebuild: true });
+        const rebuild = actions.find((a) => a.id === 'rebuild');
+        expect(rebuild.enabled).toBe(true);
+        expect(rebuild.disabledReason).toBeUndefined();
+    });
+    it('disables Rebuild Bundle when there is no machine', () => {
+        const actions = (0, reloadActions_1.reloadActions)({ running: true }, { isDevBuild: true, connected: false, includeRebuild: true });
+        expect(actions.find((a) => a.id === 'rebuild').enabled).toBe(false);
+    });
+});
+describe('describeReloadFailure names a cause, never "failed"', () => {
+    it('503 → no dev server', () => {
+        expect((0, reloadActions_1.describeReloadFailure)(503, 'dev server not available')).toContain('No dev server is running');
+    });
+    it('framework cannot hot reload → says so and points at the alternative', () => {
+        const msg = (0, reloadActions_1.describeReloadFailure)(500, 'unity does not support hot reload', {
+            running: true,
+            framework: 'unity',
+        });
+        expect(msg).toContain('unity');
+        expect(msg).toContain('Rebuild Bundle');
+    });
+    it('loopback connection refused → the dev server is not listening', () => {
+        const msg = (0, reloadActions_1.describeReloadFailure)(502, 'Get "http://127.0.0.1:8081/reload": dial tcp 127.0.0.1:8081: connect: connection refused');
+        expect(msg).toContain('not listening');
+        expect(msg).toContain('yaver dev start');
+    });
+    it('401/403 → session, not server', () => {
+        expect((0, reloadActions_1.describeReloadFailure)(401, '')).toContain('sign in again');
+        expect((0, reloadActions_1.describeReloadFailure)(403, '')).toContain('sign in again');
+    });
+    it('404 → the agent is too old, and says how to update it', () => {
+        expect((0, reloadActions_1.describeReloadFailure)(404, 'not found')).toContain('yaver-cli@latest');
+    });
+    it('5xx → points at the agent log', () => {
+        expect((0, reloadActions_1.describeReloadFailure)(500, 'boom')).toContain('yaver logs');
+    });
+    it('status 0 (transport never answered) → machine reachability', () => {
+        expect((0, reloadActions_1.describeReloadFailure)(0, '')).toContain('yaver serve');
+    });
+});

package/dist/__tests__/reloadActionsParity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/reloadActionsParity.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * `reloadActions.ts` is duplicated into yaver-feedback-react-native and
+ * yaver-feedback-web on purpose — they are two independently published npm
+ * packages, and neither may depend on the other.
+ *
+ * Duplication without a guard is DRIFT, and drift in this file is the worst
+ * kind: it is a *policy* file. If the web copy stops returning [] for a
+ * production build and the RN copy still does, the two SDKs disagree about
+ * whether a shipped app may show a reload button — and nothing in `tsc`
+ * notices, because they are separate compilation units.
+ *
+ * This is the same shape as beaconParity.test.ts in mobile/: read both
+ * sources, assert they agree. Prove it by breaking it — change one word in
+ * either copy and this test fails.
+ */
+const RN_COPY = (0, path_1.join)(__dirname, '..', 'reloadActions.ts');
+const WEB_COPY = (0, path_1.join)(__dirname, '..', '..', '..', // sdk/feedback/react-native
+'web', 'src', 'reloadActions.ts');
+describe('reloadActions parity between the RN and web SDKs', () => {
+    it('both copies exist', () => {
+        expect(() => (0, fs_1.readFileSync)(RN_COPY, 'utf8')).not.toThrow();
+        expect(() => (0, fs_1.readFileSync)(WEB_COPY, 'utf8')).not.toThrow();
+    });
+    it('is byte-identical across the two packages', () => {
+        const rn = (0, fs_1.readFileSync)(RN_COPY, 'utf8');
+        const web = (0, fs_1.readFileSync)(WEB_COPY, 'utf8');
+        expect(rn).toEqual(web);
+    });
+    it('still carries the production guard in BOTH copies', () => {
+        // Named separately from the byte comparison so that if someone
+        // legitimately reformats both files the failure still points at the one
+        // line that actually matters.
+        for (const [name, path] of [['react-native', RN_COPY], ['web', WEB_COPY]]) {
+            const source = (0, fs_1.readFileSync)(path, 'utf8');
+            expect(`${name}: ${source.includes('if (!opts.isDevBuild) return [];')}`).toEqual(`${name}: true`);
+        }
+    });
+});

package/dist/__tests__/types.test.js

@@ -39,7 +39,7 @@ describe('React Native SDK types', () => {
             const bundle = {
                 metadata: {
                     timestamp: '2026-03-24T12:00:00Z',
-                    device: {
+                    deviceInfo: {
                         platform: 'ios',
                         osVersion: '18.0',
                         model: 'iPhone 16 Pro',
@@ -55,7 +55,7 @@ describe('React Native SDK types', () => {
                 screenshots: [],
             };
             expect(bundle.metadata.timestamp).toBe('2026-03-24T12:00:00Z');
-            expect(bundle.metadata.device.platform).toBe('ios');
+            expect(bundle.metadata.deviceInfo.platform).toBe('ios');
             expect(bundle.screenshots).toEqual([]);
             expect(bundle.video).toBeUndefined();
         });
@@ -63,7 +63,7 @@ describe('React Native SDK types', () => {
             const bundle = {
                 metadata: {
                     timestamp: '2026-03-24T12:00:00Z',
-                    device: {
+                    deviceInfo: {
                         platform: 'android',
                         osVersion: '15',
                         model: 'Pixel 9',
@@ -146,7 +146,7 @@ describe('React Native SDK types', () => {
                 bundle: {
                     metadata: {
                         timestamp: 'now',
-                        device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+                        deviceInfo: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
                         app: {},
                     },
                     screenshots: [],
@@ -164,7 +164,7 @@ describe('React Native SDK types', () => {
                     bundle: {
                         metadata: {
                             timestamp: 'now',
-                            device: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
+                            deviceInfo: { platform: 'ios', osVersion: '18', model: 'iPhone', screenWidth: 393, screenHeight: 852 },
                             app: {},
                         },
                         screenshots: [],

package/dist/_core/device.d.ts

@@ -39,18 +39,28 @@ export declare function mergeDeviceEntries(a: CoreDevice, b: CoreDevice): CoreDe
  */
 export declare function collapseDevices(devices: CoreDevice[]): CoreDevice[];
 /**
- * "Fresh" matches the mobile app: online + heartbeat < 90 s. Clients
- * read Convex's `isOnline` first (backend already applies its own 90 s
- * gate from the server clock), then use this helper when they need the
- * phone-side freshness opinion too — e.g. for auto-connect picks.
+ * "Fresh" matches the mobile app: online + heartbeat within
+ * HEARTBEAT_STALE_MS. Clients read Convex's `isOnline` first (the backend
+ * applies the same gate from the server clock), then use this helper when
+ * they need the phone-side freshness opinion too — e.g. for auto-connect
+ * picks.
  */
 export declare function isDeviceFresh(d: CoreDevice, now?: number): boolean;
 /**
- * Choose the best candidate for an auto-connect attempt. Preference:
- *   1. explicit `preferredDeviceId` that's still fresh
- *   2. fresh (online + recent heartbeat) + has a quicHost
- *   3. online + has a quicHost
- *   4. first with a quicHost
+ * Choose the best candidate for an auto-connect attempt.
+ *
+ * An explicit `preferredDeviceId` is honoured by id ALONE, or not at all:
+ *   - A missing `quicHost` is not grounds to reroute. Relay transport
+ *     addresses a device by id (`<relay>/d/<deviceId>`), so the entry is
+ *     still reachable off-LAN — which is precisely when quicHost is absent.
+ *   - If the id is not in the list, return null. Falling through to another
+ *     machine silently lands the user's fix on the wrong host: they pick the
+ *     Mac mini, the commit shows up on the laptop, and nothing reports an
+ *     error. Not connecting is the better failure — the caller surfaces
+ *     "selected machine missing, re-select it".
+ *
+ * With no preference, fall back: fresh + quicHost → online + quicHost →
+ * first with a quicHost.
  */
 export declare function pickTargetDevice(devices: CoreDevice[], preferredDeviceId?: string): CoreDevice | null;
 /**

package/dist/_core/device.js

@@ -182,10 +182,11 @@ function collapseDevices(devices) {
 }
 // ── Freshness + target pick ───────────────────────────────────────────
 /**
- * "Fresh" matches the mobile app: online + heartbeat < 90 s. Clients
- * read Convex's `isOnline` first (backend already applies its own 90 s
- * gate from the server clock), then use this helper when they need the
- * phone-side freshness opinion too — e.g. for auto-connect picks.
+ * "Fresh" matches the mobile app: online + heartbeat within
+ * HEARTBEAT_STALE_MS. Clients read Convex's `isOnline` first (the backend
+ * applies the same gate from the server clock), then use this helper when
+ * they need the phone-side freshness opinion too — e.g. for auto-connect
+ * picks.
  */
 function isDeviceFresh(d, now = Date.now()) {
     if (!d.isOnline)
@@ -195,21 +196,26 @@ function isDeviceFresh(d, now = Date.now()) {
     return now - d.lastHeartbeat < constants_1.HEARTBEAT_STALE_MS;
 }
 /**
- * Choose the best candidate for an auto-connect attempt. Preference:
- *   1. explicit `preferredDeviceId` that's still fresh
- *   2. fresh (online + recent heartbeat) + has a quicHost
- *   3. online + has a quicHost
- *   4. first with a quicHost
+ * Choose the best candidate for an auto-connect attempt.
+ *
+ * An explicit `preferredDeviceId` is honoured by id ALONE, or not at all:
+ *   - A missing `quicHost` is not grounds to reroute. Relay transport
+ *     addresses a device by id (`<relay>/d/<deviceId>`), so the entry is
+ *     still reachable off-LAN — which is precisely when quicHost is absent.
+ *   - If the id is not in the list, return null. Falling through to another
+ *     machine silently lands the user's fix on the wrong host: they pick the
+ *     Mac mini, the commit shows up on the laptop, and nothing reports an
+ *     error. Not connecting is the better failure — the caller surfaces
+ *     "selected machine missing, re-select it".
+ *
+ * With no preference, fall back: fresh + quicHost → online + quicHost →
+ * first with a quicHost.
  */
 function pickTargetDevice(devices, preferredDeviceId) {
     if (!devices.length)
         return null;
     if (preferredDeviceId) {
-        const preferred = devices.find((d) => d.deviceId === preferredDeviceId && d.quicHost);
-        if (preferred && isDeviceFresh(preferred))
-            return preferred;
-        if (preferred)
-            return preferred;
+        return devices.find((d) => d.deviceId === preferredDeviceId) ?? null;
     }
     const fresh = devices.find((d) => isDeviceFresh(d) && d.quicHost);
     if (fresh)

package/dist/capture.d.ts

@@ -88,3 +88,9 @@ export declare function stopAudioRecording(): Promise<{
 } | null>;
 /** Whether a voice-note recording is currently active. */
 export declare function isAudioRecording(): boolean;
+/** Begin a raw-PCM recording for the voice stream. */
+export declare function startPcmRecording(): Promise<void>;
+/** Stop the voice recording; returns the WAV file:// URI (or null). */
+export declare function stopPcmRecording(): Promise<string | null>;
+/** Whether a voice-stream recording is currently active. */
+export declare function isPcmRecording(): boolean;

package/dist/capture.js

@@ -25,6 +25,9 @@ exports.isVoiceCaptureSupported = isVoiceCaptureSupported;
 exports.startAudioRecording = startAudioRecording;
 exports.stopAudioRecording = stopAudioRecording;
 exports.isAudioRecording = isAudioRecording;
+exports.startPcmRecording = startPcmRecording;
+exports.stopPcmRecording = stopPcmRecording;
+exports.isPcmRecording = isPcmRecording;
 /**
  * Capture the current screen as a PNG image.
  * Requires `react-native-view-shot` to be installed.
@@ -307,3 +310,53 @@ async function stopAudioRecording() {
 function isAudioRecording() {
     return audioRecorderActive;
 }
+// ── Voice-stream recording (raw LPCM WAV) ──────────────────────────────
+// The voice vibe-coding path streams audio to the agent's STT WS, which
+// expects raw 16-bit / 16 kHz mono PCM (we strip the WAV header on the
+// way out). That's a different format from the HIGH_QUALITY m4a recorder
+// above — a compressed .m4a can't be streamed to Deepgram/whisper — so
+// this uses its own recording options, mirroring the Yaver app's
+// AgentVoiceButton.
+let pcmRecorderRef = null;
+let pcmRecorderActive = false;
+// Raw LPCM 16-bit LE, 16 kHz mono. iOS uses lpcm; Android records WAV.
+const PCM_RECORDING_OPTIONS = {
+    android: { extension: '.wav', outputFormat: 2, audioEncoder: 3, sampleRate: 16000, numberOfChannels: 1, bitRate: 256000 },
+    ios: {
+        extension: '.wav', outputFormat: 'lpcm', audioQuality: 0x40, sampleRate: 16000,
+        numberOfChannels: 1, bitRate: 256000, linearPCMBitDepth: 16, linearPCMIsBigEndian: false, linearPCMIsFloat: false,
+    },
+    web: { mimeType: 'audio/wav', bitsPerSecond: 256000 },
+};
+/** Begin a raw-PCM recording for the voice stream. */
+async function startPcmRecording() {
+    if (pcmRecorderActive)
+        throw new Error('[YaverFeedback] A voice recording is already in progress.');
+    const ExpoAv = loadExpoAvOrThrow();
+    const { Audio } = ExpoAv;
+    const perm = await Audio.requestPermissionsAsync();
+    if (!perm.granted) {
+        throw new Error('[YaverFeedback] Microphone permission denied. Enable it in Settings ▸ Your App ▸ Microphone.');
+    }
+    await Audio.setAudioModeAsync({ allowsRecordingIOS: true, playsInSilentModeIOS: true, staysActiveInBackground: false });
+    const { recording } = await Audio.Recording.createAsync(PCM_RECORDING_OPTIONS);
+    pcmRecorderRef = recording;
+    pcmRecorderActive = true;
+}
+/** Stop the voice recording; returns the WAV file:// URI (or null). */
+async function stopPcmRecording() {
+    if (!pcmRecorderActive || !pcmRecorderRef)
+        return null;
+    const recording = pcmRecorderRef;
+    pcmRecorderRef = null;
+    pcmRecorderActive = false;
+    try {
+        await recording.stopAndUnloadAsync();
+    }
+    catch { /* already stopped */ }
+    return typeof recording.getURI === 'function' ? recording.getURI() : null;
+}
+/** Whether a voice-stream recording is currently active. */
+function isPcmRecording() {
+    return pcmRecorderActive;
+}

package/dist/index.d.ts

@@ -28,12 +28,16 @@
  * ```
  */
 export { YaverFeedback } from './YaverFeedback';
+export { captureStoreScreenshots } from './storeShots';
+export type { CaptureStoreScreenshotsOptions, CaptureStoreScreenshotsResult, StoreShotFrame, } from './storeShots';
 export { BlackBox } from './BlackBox';
 export { YaverUpdates } from './YaverUpdates';
 export type { YaverUpdatesConfig, PendingUpdate } from './YaverUpdates';
 export { initExpo } from './expo';
 export { YaverDiscovery } from './Discovery';
 export { P2PClient } from './P2PClient';
+export { reloadActions, reloadRequest, reloadFrameworkFamily, describeReloadFailure, RELOAD_PATH, RELOAD_APP_PATH, } from './reloadActions';
+export type { ReloadAction, ReloadActionId, ReloadActionsOptions, ReloadWireMode, DevServerSnapshot, } from './reloadActions';
 export { YaverConnectionScreen } from './ConnectionScreen';
 export { YaverLoginScreen } from './LoginScreen';
 export type { YaverLoginScreenProps } from './LoginScreen';