yaver-feedback-react-native 0.7.16 → 0.8.0

package/dist/FeedbackModal.js

@@ -40,6 +40,7 @@ const YaverFeedback_1 = require("./YaverFeedback");
 const capture_1 = require("./capture");
 const upload_1 = require("./upload");
 const AuthOverlay_1 = require("./AuthOverlay");
+const QuickActionIcon_1 = require("./QuickActionIcon");
 const FeedbackModal = () => {
     const [visible, setVisible] = (0, react_1.useState)(false);
     const [action, setAction] = (0, react_1.useState)('idle');
@@ -52,6 +53,19 @@ const FeedbackModal = () => {
     // hidden button instead of a runtime error.
     const voiceSupported = (0, react_1.useRef)((0, capture_1.isVoiceCaptureSupported)()).current;
     const [lastVideo, setLastVideo] = (0, react_1.useState)(null);
+    // Tracks whether the user has hidden the QuickActionIcon via its
+    // long-press menu. Shake is always available, so the feedback modal
+    // is our guaranteed UI for bringing the icon back — we surface a
+    // small "Show quick icon" row when this is true.
+    const [quickIconHidden, setQuickIconHidden] = (0, react_1.useState)(false);
+    // Vibing-input mode: same expand-on-tap pattern as email login.
+    // Tap "Vibing" once → the button reveals an input + Send; that lets
+    // the user say WHAT they want to vibe on instead of firing a canned
+    // "pick something for me" prompt (which in 0.7.13 pointed Claude at
+    // the wrong project because the matcher grepped the prompt itself).
+    const [showVibeInput, setShowVibeInput] = (0, react_1.useState)(false);
+    const [vibePrompt, setVibePrompt] = (0, react_1.useState)('');
+    const [lastVibeTaskId, setLastVibeTaskId] = (0, react_1.useState)(null);
     const mountedRef = (0, react_1.useRef)(true);
     (0, react_1.useEffect)(() => {
         mountedRef.current = true;
@@ -61,6 +75,15 @@ const FeedbackModal = () => {
                 setError(null);
                 setToast(null);
                 setAction('idle');
+                // Re-read the "user hid the quick icon" flag on every open so
+                // the re-enable row reflects the latest preference (the user
+                // might have hidden or shown it between opens).
+                YaverFeedback_1.YaverFeedback.isQuickIconHidden()
+                    .then((v) => {
+                    if (mountedRef.current)
+                        setQuickIconHidden(v);
+                })
+                    .catch(() => { });
             }
         });
         // Agent streams build / compile progress through the BlackBox
@@ -263,7 +286,22 @@ const FeedbackModal = () => {
         }
     }, [closeSoon]);
     // ─── 3. Vibing ─────────────────────────────────────────────────────
-    const handleVibing = (0, react_1.useCallback)(async () => {
+    // First tap expands the input; second submit fires the actual
+    // /vibing/execute. Mirrors the Yaver mobile app's Vibing tab —
+    // user types what they want, hits Send, sees the task id back. If
+    // left blank, we default to "pick the next small improvement"
+    // so a one-tap workflow still works for lazy days.
+    const handleVibingButton = (0, react_1.useCallback)(() => {
+        if (!showVibeInput) {
+            setShowVibeInput(true);
+            return;
+        }
+        // collapse if tapped again with empty input
+        if (!vibePrompt.trim()) {
+            setShowVibeInput(false);
+        }
+    }, [showVibeInput, vibePrompt]);
+    const handleVibingSubmit = (0, react_1.useCallback)(async () => {
         const client = YaverFeedback_1.YaverFeedback.getP2PClient();
         if (!client) {
             setError('Not connected to the agent yet.');
@@ -280,14 +318,16 @@ const FeedbackModal = () => {
                         .map((e) => `- ${e.message}`)
                         .join('\n')
                 : '';
-            const prompt = 'The user opened the feedback modal on their phone and tapped Vibing. ' +
-                'Investigate whatever they are likely to be asking about — pick the ' +
-                'next small improvement or fix based on recent activity and the ' +
-                'current screen.' +
-                errNote;
-            await client.vibing(prompt);
-            setToast('Vibing task created');
-            closeSoon(1200);
+            const userPrompt = vibePrompt.trim();
+            const prompt = userPrompt
+                ? userPrompt + errNote
+                : 'Pick the next small improvement or fix for this app based on recent activity and the current screen.' +
+                    errNote;
+            const result = await client.vibing(prompt);
+            setLastVibeTaskId(result.taskId);
+            setToast(`Vibing task ${result.taskId.slice(0, 8)} created`);
+            setVibePrompt('');
+            setShowVibeInput(false);
         }
         catch (err) {
             setError(err instanceof Error ? err.message : String(err));
@@ -296,7 +336,7 @@ const FeedbackModal = () => {
             if (mountedRef.current)
                 setAction('idle');
         }
-    }, [closeSoon]);
+    }, [vibePrompt]);
     // ─── 4. Toggle screen recording ────────────────────────────────────
     const handleToggleRecording = (0, react_1.useCallback)(async () => {
         setError(null);
@@ -471,6 +511,7 @@ const FeedbackModal = () => {
     const busy = action !== 'idle';
     return (<>
       <AuthOverlay_1.AuthOverlay />
+      <QuickActionIcon_1.QuickActionIcon />
       {visible && (<react_native_1.Modal visible={visible} animationType="slide" transparent onRequestClose={handleClose}>
           <react_native_1.Pressable style={styles.overlay} onPress={handleClose}>
             <react_native_1.Pressable style={styles.modal} onPress={(e) => e.stopPropagation()}>
@@ -489,8 +530,30 @@ const FeedbackModal = () => {
                 ? 'Capturing…'
                 : 'Screenshot & Fix'} tint="#22c55e" onPress={handleScreenshotAndFix} disabled={busy} busy={action === 'capturing'}/>
 
-              {/* 3. Vibing */}
-              <ActionRow label={action === 'vibing' ? 'Starting…' : 'Vibing'} tint="#818cf8" onPress={handleVibing} disabled={busy} busy={action === 'vibing'}/>
+              {/* 3. Vibing — expands to an input box on first tap
+                 so the user says WHAT they want to vibe on, just
+                 like the Yaver mobile app's Vibing tab. Second
+                 tap (Send) fires /vibing/execute with the typed
+                 prompt + resolved bundle id so the agent routes
+                 to the right repo. */}
+              {!showVibeInput ? (<ActionRow label={action === 'vibing' ? 'Starting…' : 'Vibing'} tint="#818cf8" onPress={handleVibingButton} disabled={busy} busy={action === 'vibing'}/>) : (<react_native_1.View style={styles.vibeInputRow}>
+                  <react_native_1.TextInput style={styles.vibeInput} placeholder="What do you want to vibe on?" placeholderTextColor="#666" value={vibePrompt} onChangeText={setVibePrompt} multiline autoFocus editable={action !== 'vibing'} blurOnSubmit={false}/>
+                  <react_native_1.View style={styles.vibeInputButtons}>
+                    <react_native_1.Pressable onPress={() => { setShowVibeInput(false); setVibePrompt(''); }} style={({ pressed }) => [styles.vibeCancelBtn, pressed && styles.buttonPressed]} disabled={action === 'vibing'}>
+                      <react_native_1.Text style={styles.vibeCancelBtnText}>Cancel</react_native_1.Text>
+                    </react_native_1.Pressable>
+                    <react_native_1.Pressable onPress={handleVibingSubmit} style={({ pressed }) => [
+                    styles.vibeSendBtn,
+                    pressed && styles.buttonPressed,
+                    action === 'vibing' && { opacity: 0.6 },
+                ]} disabled={action === 'vibing'}>
+                      {action === 'vibing' ? (<react_native_1.ActivityIndicator color="#fff"/>) : (<react_native_1.Text style={styles.vibeSendBtnText}>Send</react_native_1.Text>)}
+                    </react_native_1.Pressable>
+                  </react_native_1.View>
+                </react_native_1.View>)}
+              {lastVibeTaskId && action !== 'vibing' && (<react_native_1.Text style={styles.vibeTaskLine} numberOfLines={1}>
+                  Last vibing task: {lastVibeTaskId.slice(0, 12)}…
+                </react_native_1.Text>)}
 
               {/* Voice note — only rendered when expo-av is installed.
                 Tap to start, tap again to stop → transcribes via
@@ -519,6 +582,27 @@ const FeedbackModal = () => {
                 </react_native_1.View>)}
               {toast && <react_native_1.Text style={styles.toast}>{toast}</react_native_1.Text>}
               {error && <react_native_1.Text style={styles.error}>{error}</react_native_1.Text>}
+
+              {/* Quick-icon toggle. The user's three ways to control
+                the floating icon are: (1) long-press the icon →
+                Hide, (2) tap this row to toggle it on/off, (3) shake
+                → this modal → tap this row. Shake is the unkillable
+                back-door when the icon is hidden and the dev hasn't
+                exposed their own settings UI. */}
+              <react_native_1.Pressable onPress={async () => {
+                const next = !quickIconHidden;
+                setQuickIconHidden(next);
+                await YaverFeedback_1.YaverFeedback.setQuickIconVisible(!next);
+            }} style={({ pressed }) => [
+                styles.quickIconToggle,
+                pressed && { opacity: 0.7 },
+            ]} accessibilityRole="button" accessibilityLabel={quickIconHidden ? 'Show quick icon' : 'Hide quick icon'}>
+                <react_native_1.Text style={styles.quickIconToggleText}>
+                  {quickIconHidden
+                ? '◯  Show quick-access icon'
+                : '●  Hide quick-access icon'}
+                </react_native_1.Text>
+              </react_native_1.Pressable>
             </react_native_1.Pressable>
           </react_native_1.Pressable>
         </react_native_1.Modal>)}
@@ -537,6 +621,56 @@ const ActionRow = ({ label, tint, onPress, disabled, busy, }) => (<react_native_
     {busy ? (<react_native_1.ActivityIndicator color={tint} size="small"/>) : (<react_native_1.Text style={[styles.actionText, { color: tint }]}>{label}</react_native_1.Text>)}
   </react_native_1.Pressable>);
 const styles = react_native_1.StyleSheet.create({
+    vibeInputRow: {
+        backgroundColor: 'rgba(129,140,248,0.08)',
+        borderColor: 'rgba(129,140,248,0.4)',
+        borderWidth: 1,
+        borderRadius: 12,
+        padding: 12,
+        gap: 10,
+    },
+    vibeInput: {
+        color: '#fff',
+        fontSize: 15,
+        minHeight: 64,
+        textAlignVertical: 'top',
+        padding: 0,
+    },
+    vibeInputButtons: {
+        flexDirection: 'row',
+        justifyContent: 'flex-end',
+        gap: 10,
+    },
+    vibeCancelBtn: {
+        paddingHorizontal: 14,
+        paddingVertical: 8,
+        borderRadius: 8,
+        backgroundColor: 'transparent',
+    },
+    vibeCancelBtnText: {
+        color: '#999',
+        fontSize: 14,
+        fontWeight: '600',
+    },
+    vibeSendBtn: {
+        paddingHorizontal: 16,
+        paddingVertical: 8,
+        borderRadius: 8,
+        backgroundColor: '#818cf8',
+        minWidth: 72,
+        alignItems: 'center',
+    },
+    vibeSendBtnText: {
+        color: '#fff',
+        fontSize: 14,
+        fontWeight: '700',
+    },
+    vibeTaskLine: {
+        color: '#818cf8',
+        fontSize: 12,
+        marginTop: -4,
+        fontFamily: react_native_1.Platform.select({ ios: 'Menlo', android: 'monospace', default: 'monospace' }),
+    },
     overlay: {
         flex: 1,
         backgroundColor: 'rgba(0,0,0,0.55)',
@@ -613,4 +747,15 @@ const styles = react_native_1.StyleSheet.create({
         textAlign: 'center',
         marginTop: 4,
     },
+    quickIconToggle: {
+        marginTop: 4,
+        alignSelf: 'center',
+        paddingVertical: 6,
+        paddingHorizontal: 12,
+    },
+    quickIconToggleText: {
+        color: '#9ca3af',
+        fontSize: 12,
+        fontWeight: '500',
+    },
 });

package/dist/P2PClient.d.ts

@@ -83,7 +83,11 @@ export declare class P2PClient {
      * 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<{
+    vibing(prompt: string, opts?: {
+        projectName?: string;
+        bundleId?: string;
+        projectPath?: string;
+    }): Promise<{
         taskId: string;
     }>;
     /**

package/dist/P2PClient.js

@@ -327,14 +327,27 @@ class P2PClient {
      * 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) {
+    async vibing(prompt, opts) {
+        // Resolve app identity exactly the same way we do for
+        // reloadApp — bundle ID from expo-constants or native config.
+        // Without this, the agent falls back to "grep the prompt for a
+        // word that looks like a project name," which is catastrophically
+        // wrong: the prompt 'tapped Vibing' matched 'in' → picked mprint
+        // → Claude vibed on the wrong repo. Passing the bundle/name lets
+        // the agent go straight to findMobileProjectByName / bundleId.
+        const identity = resolveAppIdentity(opts);
         const response = await fetch(`${this.baseUrl}/vibing/execute`, {
             method: 'POST',
             headers: {
                 Authorization: `Bearer ${this.authToken}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ prompt, projectPath: projectPath ?? '' }),
+            body: JSON.stringify({
+                prompt,
+                projectPath: identity.projectPath ?? opts?.projectPath ?? '',
+                projectName: identity.projectName,
+                bundleId: identity.bundleId,
+            }),
         });
         if (!response.ok) {
             const text = await response.text().catch(() => '');

package/dist/QuickActionIcon.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+export interface QuickActionIconProps {
+    /** Override the color from FeedbackConfig.quickIconColor. */
+    color?: string;
+    /** Override the initial position from FeedbackConfig.quickIconInitialPosition. */
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    /** Override the icon diameter. Default 44. */
+    size?: number;
+}
+/**
+ * Small tap-to-open icon for the Yaver Feedback SDK.
+ *
+ * Default UX:
+ *  - **Tap** opens the feedback modal (same as shake).
+ *  - **Long-press** (~550ms) opens a menu with "Open feedback" and
+ *    "Hide icon". Hiding is persisted to AsyncStorage so the user's
+ *    decision survives app relaunches.
+ *  - **Drag** repositions the icon.
+ *
+ * Shake always keeps working independently — even when the icon is
+ * hidden the user can still shake to open feedback.
+ *
+ * Visibility is controlled by `FeedbackConfig.quickIcon`:
+ *  - `'auto'` (default) → `'always'` on iOS/Android, `'off'` on web.
+ *  - `'always'` → visible from first render.
+ *  - `'after-shake'` → hidden until `yaverFeedback:firstShake` fires.
+ *  - `'off'` → never rendered.
+ *
+ * Suppressed entirely when the SDK is loaded inside Yaver's super-host
+ * (the Yaver mobile app owns the shake gesture + overlay in that case).
+ */
+export declare const QuickActionIcon: React.FC<QuickActionIconProps>;

package/dist/QuickActionIcon.js

@@ -0,0 +1,299 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickActionIcon = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const YaverFeedback_1 = require("./YaverFeedback");
+const preferences_1 = require("./preferences");
+// Mirror the suppression rule used by YaverFeedback + ShakeDetector:
+// when loaded through Yaver's super-host Hermes bundle, the host owns
+// shake + reload UX. We must not render a second action surface.
+function isRunningInsideYaverHost() {
+    try {
+        return !!react_native_1.NativeModules?.YaverInfo;
+    }
+    catch {
+        return false;
+    }
+}
+const DEFAULT_SIZE = 44;
+const DEFAULT_COLOR = '#6366f1';
+const LONG_PRESS_MS = 550;
+/**
+ * Small tap-to-open icon for the Yaver Feedback SDK.
+ *
+ * Default UX:
+ *  - **Tap** opens the feedback modal (same as shake).
+ *  - **Long-press** (~550ms) opens a menu with "Open feedback" and
+ *    "Hide icon". Hiding is persisted to AsyncStorage so the user's
+ *    decision survives app relaunches.
+ *  - **Drag** repositions the icon.
+ *
+ * Shake always keeps working independently — even when the icon is
+ * hidden the user can still shake to open feedback.
+ *
+ * Visibility is controlled by `FeedbackConfig.quickIcon`:
+ *  - `'auto'` (default) → `'always'` on iOS/Android, `'off'` on web.
+ *  - `'always'` → visible from first render.
+ *  - `'after-shake'` → hidden until `yaverFeedback:firstShake` fires.
+ *  - `'off'` → never rendered.
+ *
+ * Suppressed entirely when the SDK is loaded inside Yaver's super-host
+ * (the Yaver mobile app owns the shake gesture + overlay in that case).
+ */
+const QuickActionIcon = ({ color: colorProp, initialPosition: initialPositionProp, size = DEFAULT_SIZE, }) => {
+    const config = YaverFeedback_1.YaverFeedback.getConfig();
+    const mode = (() => {
+        const raw = config?.quickIcon ?? 'auto';
+        if (raw === 'auto') {
+            return react_native_1.Platform.OS === 'web' ? 'off' : 'always';
+        }
+        return raw;
+    })();
+    const color = colorProp ?? config?.quickIconColor ?? DEFAULT_COLOR;
+    const { width, height } = react_native_1.Dimensions.get('window');
+    const defaultStart = initialPositionProp ??
+        config?.quickIconInitialPosition ?? {
+        x: Math.max(width - size - 14, 0),
+        y: Math.max(Math.floor(height * 0.35), 80),
+    };
+    const pan = (0, react_1.useRef)(new react_native_1.Animated.ValueXY(defaultStart)).current;
+    const lastPos = (0, react_1.useRef)(defaultStart);
+    const dragStart = (0, react_1.useRef)(null);
+    const didDrag = (0, react_1.useRef)(false);
+    const [userDisabled, setUserDisabled] = (0, react_1.useState)(null);
+    const [shakenThisSession, setShakenThisSession] = (0, react_1.useState)(false);
+    const [menuOpen, setMenuOpen] = (0, react_1.useState)(false);
+    const [hostSuppressed] = (0, react_1.useState)(() => isRunningInsideYaverHost());
+    // Load the persisted disable flag once on mount. Until it resolves we
+    // render nothing — a one-frame flash of the icon before hiding would
+    // be worse than a tiny delayed appearance.
+    (0, react_1.useEffect)(() => {
+        let alive = true;
+        (0, preferences_1.getQuickIconDisabled)().then((v) => {
+            if (alive)
+                setUserDisabled(v);
+        });
+        return () => {
+            alive = false;
+        };
+    }, []);
+    // `after-shake` mode waits for the first shake before revealing
+    // itself. YaverFeedback emits this event from its shake callback.
+    (0, react_1.useEffect)(() => {
+        const sub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:firstShake', () => setShakenThisSession(true));
+        return () => sub.remove();
+    }, []);
+    // Programmatic control: host apps can call
+    // `YaverFeedback.setQuickIconVisible(true)` to re-surface the icon
+    // after the user hid it (e.g. from a settings screen).
+    (0, react_1.useEffect)(() => {
+        const showSub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:quickIconShow', () => {
+            setUserDisabled(false);
+            void (0, preferences_1.setQuickIconDisabled)(false);
+        });
+        const hideSub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:quickIconHide', () => {
+            setUserDisabled(true);
+            void (0, preferences_1.setQuickIconDisabled)(true);
+            setMenuOpen(false);
+        });
+        return () => {
+            showSub.remove();
+            hideSub.remove();
+        };
+    }, []);
+    const panResponder = (0, react_1.useRef)(react_native_1.PanResponder.create({
+        onStartShouldSetPanResponder: () => true,
+        onMoveShouldSetPanResponder: (_, g) => Math.abs(g.dx) > 3 || Math.abs(g.dy) > 3,
+        onPanResponderGrant: () => {
+            didDrag.current = false;
+            dragStart.current = { ...lastPos.current };
+            pan.setOffset({ x: lastPos.current.x, y: lastPos.current.y });
+            pan.setValue({ x: 0, y: 0 });
+        },
+        onPanResponderMove: (_, g) => {
+            if (Math.abs(g.dx) > 3 || Math.abs(g.dy) > 3) {
+                didDrag.current = true;
+            }
+            react_native_1.Animated.event([null, { dx: pan.x, dy: pan.y }], {
+                useNativeDriver: false,
+            })(_, g);
+        },
+        onPanResponderRelease: (_, g) => {
+            pan.flattenOffset();
+            const start = dragStart.current ?? lastPos.current;
+            const maxX = Math.max(width - size, 0);
+            const maxY = Math.max(height - size, 0);
+            const nextX = Math.max(0, Math.min(maxX, start.x + g.dx));
+            const nextY = Math.max(0, Math.min(maxY, start.y + g.dy));
+            lastPos.current = { x: nextX, y: nextY };
+            react_native_1.Animated.spring(pan, {
+                toValue: { x: nextX, y: nextY },
+                useNativeDriver: false,
+                friction: 7,
+            }).start();
+        },
+    })).current;
+    const openFeedback = (0, react_1.useCallback)(() => {
+        setMenuOpen(false);
+        void YaverFeedback_1.YaverFeedback.startReport();
+    }, []);
+    const hideForever = (0, react_1.useCallback)(() => {
+        setMenuOpen(false);
+        setUserDisabled(true);
+        void (0, preferences_1.setQuickIconDisabled)(true);
+    }, []);
+    if (hostSuppressed)
+        return null;
+    if (mode === 'off')
+        return null;
+    if (userDisabled === null)
+        return null;
+    if (userDisabled)
+        return null;
+    if (mode === 'after-shake' && !shakenThisSession)
+        return null;
+    if (!YaverFeedback_1.YaverFeedback.isEnabled())
+        return null;
+    const visualSize = size;
+    const radius = visualSize / 2;
+    return (<react_native_1.Animated.View pointerEvents="box-none" style={[
+            react_native_1.StyleSheet.absoluteFill,
+            { zIndex: 9998 },
+        ]}>
+      <react_native_1.Animated.View {...panResponder.panHandlers} style={[
+            styles.container,
+            {
+                transform: [{ translateX: pan.x }, { translateY: pan.y }],
+            },
+        ]}>
+        <react_native_1.Pressable onPress={() => {
+            if (didDrag.current) {
+                didDrag.current = false;
+                return;
+            }
+            openFeedback();
+        }} onLongPress={() => {
+            if (didDrag.current)
+                return;
+            setMenuOpen((m) => !m);
+        }} delayLongPress={LONG_PRESS_MS} hitSlop={6} accessibilityRole="button" accessibilityLabel="Open Yaver feedback" style={({ pressed }) => [
+            styles.icon,
+            {
+                width: visualSize,
+                height: visualSize,
+                borderRadius: radius,
+                backgroundColor: color,
+                opacity: pressed ? 0.85 : 1,
+            },
+        ]}>
+          <react_native_1.Text style={[styles.iconLabel, { fontSize: Math.round(visualSize * 0.5) }]}>y</react_native_1.Text>
+        </react_native_1.Pressable>
+        {menuOpen ? (<react_native_1.View style={styles.menu}>
+            <react_native_1.Pressable onPress={openFeedback} style={({ pressed }) => [
+                styles.menuItem,
+                pressed && styles.menuItemPressed,
+            ]}>
+              <react_native_1.Text style={styles.menuItemText}>Open feedback</react_native_1.Text>
+            </react_native_1.Pressable>
+            <react_native_1.View style={styles.menuDivider}/>
+            <react_native_1.Pressable onPress={hideForever} style={({ pressed }) => [
+                styles.menuItem,
+                pressed && styles.menuItemPressed,
+            ]}>
+              <react_native_1.Text style={[styles.menuItemText, styles.menuItemDanger]}>
+                Hide icon
+              </react_native_1.Text>
+            </react_native_1.Pressable>
+          </react_native_1.View>) : null}
+      </react_native_1.Animated.View>
+    </react_native_1.Animated.View>);
+};
+exports.QuickActionIcon = QuickActionIcon;
+const styles = react_native_1.StyleSheet.create({
+    container: {
+        position: 'absolute',
+        top: 0,
+        left: 0,
+        alignItems: 'flex-start',
+    },
+    icon: {
+        alignItems: 'center',
+        justifyContent: 'center',
+        shadowColor: '#000',
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.25,
+        shadowRadius: 4,
+        elevation: 4,
+    },
+    iconLabel: {
+        color: '#ffffff',
+        fontWeight: '700',
+        includeFontPadding: false,
+    },
+    menu: {
+        marginTop: 6,
+        minWidth: 150,
+        backgroundColor: '#1f1f23',
+        borderRadius: 10,
+        paddingVertical: 4,
+        shadowColor: '#000',
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.3,
+        shadowRadius: 6,
+        elevation: 6,
+    },
+    menuItem: {
+        paddingHorizontal: 14,
+        paddingVertical: 10,
+    },
+    menuItemPressed: {
+        backgroundColor: '#2a2a30',
+    },
+    menuItemText: {
+        color: '#f4f4f5',
+        fontSize: 14,
+        fontWeight: '500',
+    },
+    menuItemDanger: {
+        color: '#f97316',
+    },
+    menuDivider: {
+        height: react_native_1.StyleSheet.hairlineWidth,
+        backgroundColor: '#3f3f46',
+        marginHorizontal: 8,
+    },
+});

package/dist/YaverFeedback.d.ts

@@ -199,6 +199,32 @@ export declare class YaverFeedback {
      * 3. DevSettings.reload() (Metro dev server fallback)
      */
     private static loadBundleAndReload;
+    /**
+     * Internal: fired from every shake path (dev-menu + accelerometer)
+     * before the feedback modal opens. Emits `yaverFeedback:firstShake`
+     * exactly once per process so QuickActionIcon's `'after-shake'` mode
+     * can surface itself on first shake and stay visible for the rest of
+     * the session.
+     */
+    static notifyShake(): void;
+    /**
+     * Show / hide the QuickActionIcon programmatically and persist the
+     * choice across launches. Host apps can call this from a settings
+     * screen so the user has a second way to re-enable the icon after
+     * hiding it via the icon's own long-press menu — shake is always the
+     * third back-door because it never depends on a visible control.
+     */
+    static setQuickIconVisible(visible: boolean): Promise<void>;
+    /**
+     * Returns `true` when the user has chosen to hide the QuickActionIcon
+     * (via its long-press menu or `setQuickIconVisible(false)`).
+     * FeedbackModal uses this to surface a one-tap "Show quick icon"
+     * control so the user can bring the icon back without having to know
+     * about the programmatic API.
+     */
+    static isQuickIconHidden(): Promise<boolean>;
+    /** Clear the persisted "user hid the icon" flag. */
+    static resetQuickIconPreference(): Promise<void>;
     /** Tear down the SDK (stop shake detector, clear state). */
     static destroy(): void;
 }