yaver-feedback-react-native 0.9.0 → 0.9.3

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

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

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__/YaverFeedback.test.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
 const YaverFeedback_1 = require("../YaverFeedback");
 // Mock react-native: DeviceEventEmitter for event dispatch + Platform so
 // ShakeDetector.start() can branch on iOS without hitting a real RN runtime.
@@ -33,13 +34,10 @@ jest.mock('../auth', () => ({
                 needsAuth: false,
                 runnerDown: false,
                 lastHeartbeat: Date.now(),
-                isGuest: false,
-                accessScope: 'owner',
                 quicHost: '127.0.0.1',
                 quicPort: 18080,
             },
         ],
-        shared: [],
     })),
     DEFAULT_CONVEX_SITE_URL: 'https://example.convex.site',
 }));
@@ -51,6 +49,18 @@ beforeEach(() => {
     jest.clearAllMocks();
 });
 describe('YaverFeedback', () => {
+    describe('Dogfood onboarding', () => {
+        it('starts with Yaver OAuth when the host has no session', () => {
+            YaverFeedback_1.YaverFeedback.init({ enabled: true });
+            YaverFeedback_1.YaverFeedback.beginDogfoodOnboarding({ appId: 'io.example.app', label: 'Example' });
+            expect(react_native_1.DeviceEventEmitter.emit).toHaveBeenCalledWith('yaverFeedback:startLogin');
+        });
+        it('asks for a machine after an existing OAuth session', () => {
+            YaverFeedback_1.YaverFeedback.init({ enabled: true, authToken: 'owner-token' });
+            YaverFeedback_1.YaverFeedback.beginDogfoodOnboarding({ appId: 'io.example.app', label: 'Example' });
+            expect(react_native_1.DeviceEventEmitter.emit).toHaveBeenCalledWith('yaverFeedback:startMachinePicker');
+        });
+    });
     describe('init()', () => {
         it('sets config correctly with defaults', () => {
             YaverFeedback_1.YaverFeedback.init({

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

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

package/dist/__tests__/deviceDogfood.test.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const buffer_1 = require("buffer");
+const crypto_1 = require("crypto");
+const deviceDogfood_1 = require("../deviceDogfood");
+class MemorySecureStore {
+    constructor() {
+        this.values = new Map();
+    }
+    async getItemAsync(key) { return this.values.get(key) ?? null; }
+    async setItemAsync(key, value) { this.values.set(key, value); }
+    async deleteItemAsync(key) { this.values.delete(key); }
+}
+function response(body, status = 200) {
+    return new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
+}
+describe('YaverDeviceDogfood', () => {
+    beforeAll(() => {
+        if (!globalThis.crypto)
+            globalThis.crypto = crypto_1.webcrypto;
+    });
+    afterEach(() => { jest.restoreAllMocks(); });
+    test('keeps identity stable and proves possession rather than trusting the UUID', async () => {
+        const store = new MemorySecureStore();
+        const client = new deviceDogfood_1.YaverDeviceDogfood({ appId: 'io.example.test', secureStore: store, backendUrl: 'https://dogfood.test' });
+        const first = await client.enrollmentInfo();
+        const second = await client.enrollmentInfo();
+        expect(second).toEqual(first);
+        let proof;
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/dogfood/enroll/start'))
+                return response({ status: 'pending', challenge: 'server-nonce' });
+            if (url.endsWith('/dogfood/enroll/prove')) {
+                proof = JSON.parse(String(init?.body));
+                return response({ status: 'pending', proofVerified: true });
+            }
+            throw new Error(`unexpected URL ${url}`);
+        });
+        await client.enroll('ios');
+        const message = new TextEncoder().encode(`yaver-dogfood-enroll-v1\nio.example.test\n${first.installationId}\nserver-nonce`);
+        expect(tweetnacl_1.default.sign.detached.verify(message, new Uint8Array(buffer_1.Buffer.from(proof.signature, 'base64')), new Uint8Array(buffer_1.Buffer.from(first.publicKey, 'base64')))).toBe(true);
+        const attacker = tweetnacl_1.default.sign.keyPair();
+        expect(tweetnacl_1.default.sign.detached.verify(message, new Uint8Array(buffer_1.Buffer.from(proof.signature, 'base64')), attacker.publicKey)).toBe(false);
+    });
+    test('re-register rotates key and installation while preserving only the logical slot', async () => {
+        const store = new MemorySecureStore();
+        const client = new deviceDogfood_1.YaverDeviceDogfood({ appId: 'io.example.test', secureStore: store, backendUrl: 'https://dogfood.test' });
+        const before = await client.enrollmentInfo();
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async (input) => {
+            if (String(input).endsWith('/dogfood/enroll/start'))
+                return response({ status: 'pending', challenge: 'rotate-nonce' });
+            return response({ status: 'pending', proofVerified: true });
+        });
+        await client.reRegister('ios');
+        const after = await client.enrollmentInfo();
+        expect(after.registrationSlot).toBe(before.registrationSlot);
+        expect(after.installationId).not.toBe(before.installationId);
+        expect(after.publicKey).not.toBe(before.publicKey);
+    });
+    test('exchanges an approved key proof for a short-lived scoped session', async () => {
+        const client = new deviceDogfood_1.YaverDeviceDogfood({ appId: 'io.example.test', secureStore: new MemorySecureStore(), backendUrl: 'https://dogfood.test' });
+        const identity = await client.enrollmentInfo();
+        let sessionProof;
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async (input, init) => {
+            const url = String(input);
+            if (url.includes('/dogfood/enroll/status'))
+                return response({ status: 'active' });
+            if (url.endsWith('/dogfood/session/challenge'))
+                return response({ challenge: 'session-nonce' });
+            if (url.endsWith('/dogfood/session')) {
+                sessionProof = JSON.parse(String(init?.body));
+                return response({ token: 'short-token', expiresAt: 123, scopes: ['feedback', 'blackbox'], projectSlug: 'example' });
+            }
+            throw new Error(`unexpected URL ${url}`);
+        });
+        const session = await client.session();
+        expect(session).toMatchObject({ active: true, token: 'short-token', scopes: ['feedback', 'blackbox'] });
+        const message = new TextEncoder().encode(`yaver-dogfood-session-v1\nio.example.test\n${identity.installationId}\nsession-nonce`);
+        expect(tweetnacl_1.default.sign.detached.verify(message, new Uint8Array(buffer_1.Buffer.from(sessionProof.signature, 'base64')), new Uint8Array(buffer_1.Buffer.from(identity.publicKey, 'base64')))).toBe(true);
+    });
+});

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

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

package/dist/__tests__/dogfoodPolicy.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dogfoodPolicy_1 = require("../dogfoodPolicy");
+describe('resolveSDKDogfood', () => {
+    it('fails closed unless Dogfood is explicitly enabled', () => {
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ accountIds: ['acct-1'], currentAccountId: 'acct-1' })).toMatchObject({
+            active: false,
+            code: 'SDK_DOGFOOD_DISABLED',
+        });
+    });
+    it('requires an exact approved app-account ID', () => {
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, accountIds: ['acct-1'], currentAccountId: '' }).code)
+            .toBe('SDK_DOGFOOD_ACCOUNT_REQUIRED');
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, accountIds: ['acct-1'], currentAccountId: 'acct-10' }).code)
+            .toBe('SDK_DOGFOOD_ACCOUNT_NOT_ALLOWED');
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, accountIds: ['acct-1'], currentAccountId: 'acct-1' })).toMatchObject({
+            active: true,
+            code: 'SDK_DOGFOOD_ACTIVE',
+            accountId: 'acct-1',
+        });
+    });
+    it('supports a key-enrolled installation without an app account', () => {
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, appId: 'io.example', installationStatus: 'active' }).code)
+            .toBe('SDK_DOGFOOD_INSTALLATION_REQUIRED');
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, appId: 'io.example', installationId: 'install-1', installationStatus: 'pending' }).code)
+            .toBe('SDK_DOGFOOD_INSTALLATION_NOT_ACTIVE');
+        expect((0, dogfoodPolicy_1.resolveSDKDogfood)({ enabled: true, appId: 'io.example', installationId: 'install-1', installationStatus: 'active' })).toMatchObject({
+            active: true,
+            code: 'SDK_DOGFOOD_ACTIVE',
+            accountId: 'install-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: [],