yaver-feedback-react-native 0.8.12 → 0.9.0

package/dist/capture.js

@@ -16,6 +16,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.captureScreenshot = captureScreenshot;
+exports.captureScreenshotBase64 = captureScreenshotBase64;
 exports.pickFeedbackFile = pickFeedbackFile;
 exports.startVideoRecording = startVideoRecording;
 exports.stopVideoRecording = stopVideoRecording;
@@ -24,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.
@@ -46,6 +50,34 @@ async function captureScreenshot() {
             String(err));
     }
 }
+/**
+ * Capture a screenshot AND return it as base64 + mime type, ready to
+ * embed in a `/tasks` payload's `images` array. Used by the converged
+ * vibe-feedback flow (FeedbackModal → P2PClient.createFeedbackTask).
+ *
+ * Returns null when capture isn't possible (peer dep missing / user
+ * permission denied / running in a context where view-shot can't
+ * grab the screen). Caller should treat null as "send without
+ * screenshot" rather than aborting the whole feedback.
+ */
+async function captureScreenshotBase64() {
+    try {
+        const ViewShot = require('react-native-view-shot');
+        const result = await ViewShot.captureScreen({
+            format: 'jpg',
+            quality: 0.7,
+            result: 'base64',
+        });
+        if (typeof result === 'string' && result.length > 0) {
+            // ViewShot returns a bare base64 string (no `data:` prefix).
+            return { base64: result, mimeType: 'image/jpeg' };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 function classifyPickedFile(name, mimeType) {
     const lowerName = name.toLowerCase();
     const lowerMime = (mimeType ?? '').toLowerCase();
@@ -278,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/preferences.d.ts

@@ -27,3 +27,7 @@ export declare function clearQuickIconDisabled(): Promise<void>;
 export declare function getQuickIconColorPreset(): Promise<QuickIconColorPreset | null>;
 export declare function setQuickIconColorPreset(preset: QuickIconColorPreset | null): Promise<void>;
 export declare function clearQuickIconColorPreset(): Promise<void>;
+export declare function getPreferredRunner(): Promise<string | null>;
+export declare function setPreferredRunner(runner: string | null): Promise<void>;
+export declare function getPreferredModel(): Promise<string | null>;
+export declare function setPreferredModel(model: string | null): Promise<void>;

package/dist/preferences.js

@@ -21,6 +21,10 @@ exports.clearQuickIconDisabled = clearQuickIconDisabled;
 exports.getQuickIconColorPreset = getQuickIconColorPreset;
 exports.setQuickIconColorPreset = setQuickIconColorPreset;
 exports.clearQuickIconColorPreset = clearQuickIconColorPreset;
+exports.getPreferredRunner = getPreferredRunner;
+exports.setPreferredRunner = setPreferredRunner;
+exports.getPreferredModel = getPreferredModel;
+exports.setPreferredModel = setPreferredModel;
 let AsyncStorage = null;
 try {
     AsyncStorage = require('@react-native-async-storage/async-storage').default;
@@ -137,3 +141,61 @@ async function setQuickIconColorPreset(preset) {
 async function clearQuickIconColorPreset() {
     await setQuickIconColorPreset(null);
 }
+// ── Preferred coding agent + model (used by the standalone feedback
+// SDK's vibe chat to mirror what Yaver mobile's Tasks tab would send.
+// The agent on the remote DOES read userSettings.primaryRunnerByDevice
+// from Convex, but the standalone SDK has no DeviceContext to push the
+// per-device pick. We persist the user's last choice locally; first
+// run picks whatever's signed-in via getRunnerStatus().)
+const PREFERRED_RUNNER_KEY = 'yaver_feedback_preferred_runner';
+const PREFERRED_MODEL_KEY = 'yaver_feedback_preferred_model';
+async function getPreferredRunner() {
+    if (!AsyncStorage)
+        return null;
+    try {
+        const v = await AsyncStorage.getItem(PREFERRED_RUNNER_KEY);
+        return v && v.trim() ? v.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function setPreferredRunner(runner) {
+    if (!AsyncStorage)
+        return;
+    try {
+        if (!runner || !runner.trim()) {
+            await AsyncStorage.removeItem(PREFERRED_RUNNER_KEY);
+            return;
+        }
+        await AsyncStorage.setItem(PREFERRED_RUNNER_KEY, runner.trim());
+    }
+    catch {
+        /* best-effort */
+    }
+}
+async function getPreferredModel() {
+    if (!AsyncStorage)
+        return null;
+    try {
+        const v = await AsyncStorage.getItem(PREFERRED_MODEL_KEY);
+        return v && v.trim() ? v.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function setPreferredModel(model) {
+    if (!AsyncStorage)
+        return;
+    try {
+        if (!model || !model.trim()) {
+            await AsyncStorage.removeItem(PREFERRED_MODEL_KEY);
+            return;
+        }
+        await AsyncStorage.setItem(PREFERRED_MODEL_KEY, model.trim());
+    }
+    catch {
+        /* best-effort */
+    }
+}

package/dist/types.d.ts

@@ -19,6 +19,53 @@ export interface RunnerBrowserAuthSession {
     updatedAt: number;
     completedAt?: number;
 }
+export interface RunnerAuthStatusRow {
+    id: string;
+    name: string;
+    installed: boolean;
+    ready: boolean;
+    authConfigured: boolean;
+    authSource?: string;
+    warning?: string;
+    error?: string;
+    path?: string;
+    detail?: string;
+    version?: string;
+}
+export interface OpenCodeProviderSummary {
+    id: string;
+    name?: string;
+    hasApiKey?: boolean;
+    baseUrl?: string;
+    models?: Array<{
+        id: string;
+        name?: string;
+        provider?: string;
+    }>;
+}
+export interface OpenCodeAgentSummary {
+    name: string;
+    model?: string;
+    description?: string;
+    isBuiltin?: boolean;
+}
+export interface OpenCodeConfigSummary {
+    path: string;
+    exists: boolean;
+    defaultAgent?: string;
+    model?: string;
+    smallModel?: string;
+    buildModel?: string;
+    planModel?: string;
+    providers?: OpenCodeProviderSummary[];
+    models?: Array<{
+        id: string;
+        name?: string;
+        provider?: string;
+    }>;
+    agents?: OpenCodeAgentSummary[];
+    diagnostics?: string[];
+}
 export interface IncidentEvent {
     id: string;
     timestamp: number;
@@ -118,6 +165,15 @@ export interface FeedbackConfig {
     preferredDeviceId?: string;
     /** How feedback collection is triggered */
     trigger?: 'shake' | 'floating-button' | 'manual';
+    /**
+     * App slug used by the in-modal Deploy panel when calling the agent's
+     * `/fleet/deploy-options` and `/deploy/ship` endpoints. Should match an
+     * `apps[].name` entry in the agent's `yaver.workspace.yaml`. When omitted
+     * the panel falls back to the last dot-segment of `bundleId` (e.g.
+     * `io.yaver.sfmg` → `sfmg`). Set explicitly when the workspace name
+     * differs from the bundleId tail.
+     */
+    deployAppSlug?: string;
     /**
      * Non-default escape hatch for host apps that want the SDK without
      * shake gesture handling. When enabled:
@@ -429,12 +485,20 @@ export interface TestSession {
 export interface VoiceCapability {
     /** Always true — mobile can always record and send audio. */
     voiceInputEnabled: boolean;
-    /** Speech-to-speech provider (e.g. "personaplex", "openai"), or null. */
+    /** Speech-to-speech provider (legacy), or null. */
     s2sProvider?: string;
     /** Whether the S2S provider is ready for real-time sessions. */
     s2sReady?: boolean;
-    /** Speech-to-text provider for transcription (e.g. "whisper", "openai"). */
+    /** Speech-to-text provider for transcription, e.g. "deepgram" for Deepgram Flux. */
     sttProvider?: string;
     /** Whether STT is ready (auto-transcription of voice input). */
     sttReady?: boolean;
+    /** Text-to-speech provider for readback, e.g. "cartesia". */
+    ttsProvider?: string;
+    /** Whether TTS readback is ready. */
+    ttsReady?: boolean;
+    /** Whether the agent-side hands-free task loop is enabled. */
+    enabled?: boolean;
+    /** Default project slug used by the agent voice loop. */
+    defaultProject?: string;
 }

package/dist/voice.d.ts

@@ -0,0 +1,61 @@
+export interface SDKVoiceStartOpts {
+    /** WS URL for the agent voice stream — P2PClient.voiceStreamUrl(). */
+    wsUrl: string;
+    /** Auth headers — P2PClient.voiceAuthHeaders(). */
+    headers: Record<string, string>;
+    project?: string;
+    model?: string;
+    runner?: string;
+    /** Surface hint for the agent's prompt wrapper. */
+    surface?: string;
+    /** Max chars for the spoken readback (Cartesia default ~280). */
+    ttsBudget?: number;
+    /** Per-session STT engine. "" = agent default. "local" = free
+     *  whisper.cpp on the host; "deepgram" = Flux nova-3 streaming. */
+    sttProvider?: string;
+    /** Per-session TTS engine. "" = agent default. "local"/"device" =
+     *  client synthesizes from the result text; cloud engines stream PCM. */
+    ttsProvider?: string;
+}
+export interface SDKVoiceCallbacks {
+    /** Active engines, echoed by the agent right after start — lets the UI
+     *  show "Local" vs "Flux". */
+    onProviders?: (stt: string, tts: string) => void;
+    onTranscriptPartial?: (text: string) => void;
+    onTranscriptFinal?: (text: string) => void;
+    onTaskCreated?: (taskId: string) => void;
+    onTaskResult?: (taskId: string, text: string, status: string) => void;
+    onTTSReady?: (pcm: Uint8Array, sampleRate: number) => void;
+    onError?: (msg: string) => void;
+    onDone?: () => void;
+}
+/** True when the deps the voice stream needs (expo-file-system + buffer)
+ *  are installed. The feedback UI hides the mic button otherwise. */
+export declare function isVoiceStreamSupported(): boolean;
+export declare class SDKVoiceSession {
+    private ws;
+    private callbacks;
+    private ttsChunks;
+    private ttsTotalBytes;
+    private ttsSampleRate;
+    private closed;
+    constructor(callbacks: SDKVoiceCallbacks);
+    /** Open the WS and send the start frame. Resolves once open. */
+    start(opts: SDKVoiceStartOpts): Promise<void>;
+    /** Stream a recorded WAV/PCM file as binary frames. Records produced by
+     *  recordPcmWav() are LPCM 16-bit/16kHz mono with a 44-byte RIFF header
+     *  we strip here — the exact shape the backend → STT expects. */
+    streamAudioFile(uri: string, opts?: {
+        skipWavHeader?: boolean;
+        chunkBytes?: number;
+    }): Promise<void>;
+    /** Done speaking — flush STT and create the agent task. */
+    finalize(): void;
+    close(): void;
+    private handleMessage;
+}
+/** Wrap raw PCM (signed 16-bit LE) in a minimal WAV container for
+ *  expo-av playback. 44-byte header + samples. */
+export declare function wrapPCMAsWAV(pcm: Uint8Array, sampleRate: number, channels?: number): Uint8Array;
+/** Write a PCM buffer to a temp WAV file; returns its file:// URI. */
+export declare function pcmToTempWavURI(pcm: Uint8Array, sampleRate: number): Promise<string>;

package/dist/voice.js

@@ -0,0 +1,246 @@
+"use strict";
+// Voice vibe-coding for the feedback SDK — speak a change, the agent
+// acts (full MCP), and reads back a spoken headline. Ported from the
+// Yaver mobile app's AgentVoiceSession (mobile/src/lib/agentVoice.ts) but
+// decoupled from the app: connection details (WS URL + auth headers) come
+// from the SDK's P2PClient, so it works both inside the Yaver container
+// (inherited auth) and standalone in a third-party app.
+//
+// Local vs remote STT/TTS is decided entirely agent-side (free local
+// whisper.cpp by default, Deepgram/OpenAI/etc when keys are configured),
+// so nothing model-related is bundled here — the SDK just streams mic
+// audio and renders the transcript + TTS the agent sends back.
+//
+// expo-file-system + buffer are loaded lazily so a bare-RN app that
+// hasn't installed them can still use the rest of the SDK; the voice
+// button hides itself via isVoiceStreamSupported() when they're absent.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKVoiceSession = void 0;
+exports.isVoiceStreamSupported = isVoiceStreamSupported;
+exports.wrapPCMAsWAV = wrapPCMAsWAV;
+exports.pcmToTempWavURI = pcmToTempWavURI;
+function loadBuffer() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('buffer').Buffer;
+}
+function loadFS() {
+    // expo-file-system v16+ moved the classic API under /legacy; fall back
+    // to the root export for older installs.
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('expo-file-system/legacy');
+    }
+    catch {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('expo-file-system');
+    }
+}
+/** True when the deps the voice stream needs (expo-file-system + buffer)
+ *  are installed. The feedback UI hides the mic button otherwise. */
+function isVoiceStreamSupported() {
+    try {
+        loadBuffer();
+        const fs = loadFS();
+        return typeof fs?.readAsStringAsync === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+class SDKVoiceSession {
+    constructor(callbacks) {
+        this.ws = null;
+        this.ttsChunks = [];
+        this.ttsTotalBytes = 0;
+        this.ttsSampleRate = 22050;
+        this.closed = false;
+        this.callbacks = callbacks;
+    }
+    /** Open the WS and send the start frame. Resolves once open. */
+    async start(opts) {
+        return new Promise((resolve, reject) => {
+            let opened = false;
+            let ws;
+            try {
+                // RN-specific 3rd arg carries request headers.
+                ws = new WebSocket(opts.wsUrl, undefined, { headers: opts.headers });
+            }
+            catch (e) {
+                reject(e);
+                return;
+            }
+            this.ws = ws;
+            ws.onopen = () => {
+                opened = true;
+                try {
+                    ws.send(JSON.stringify({
+                        type: 'start',
+                        project: opts.project ?? '',
+                        model: opts.model ?? '',
+                        runner: opts.runner ?? '',
+                        surface: opts.surface ?? '',
+                        ttsBudget: opts.ttsBudget ?? 0,
+                        sttProvider: opts.sttProvider ?? '',
+                        ttsProvider: opts.ttsProvider ?? '',
+                    }));
+                    resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            ws.onmessage = (e) => this.handleMessage(e);
+            ws.onerror = () => {
+                if (!opened)
+                    reject(new Error('voice WS connect failed'));
+                else
+                    this.callbacks.onError?.('voice WS error');
+            };
+            ws.onclose = () => {
+                this.closed = true;
+                if (!opened)
+                    reject(new Error('voice WS closed before open'));
+            };
+        });
+    }
+    /** Stream a recorded WAV/PCM file as binary frames. Records produced by
+     *  recordPcmWav() are LPCM 16-bit/16kHz mono with a 44-byte RIFF header
+     *  we strip here — the exact shape the backend → STT expects. */
+    async streamAudioFile(uri, opts) {
+        if (!this.ws || this.closed)
+            throw new Error('voice WS not open');
+        const Buffer = loadBuffer();
+        const FileSystem = loadFS();
+        const skipWavHeader = opts?.skipWavHeader ?? true;
+        const chunkBytes = opts?.chunkBytes ?? 16384;
+        const b64 = await FileSystem.readAsStringAsync(uri, { encoding: 'base64' });
+        let buf = Buffer.from(b64, 'base64');
+        if (skipWavHeader && buf.length > 44 && buf.slice(0, 4).toString() === 'RIFF') {
+            buf = buf.slice(44);
+        }
+        for (let i = 0; i < buf.length; i += chunkBytes) {
+            if (this.closed)
+                return;
+            const slice = buf.slice(i, Math.min(i + chunkBytes, buf.length));
+            this.ws.send(slice.buffer.slice(slice.byteOffset, slice.byteOffset + slice.byteLength));
+            await new Promise((r) => setTimeout(r, 0));
+        }
+    }
+    /** Done speaking — flush STT and create the agent task. */
+    finalize() {
+        if (this.ws && !this.closed) {
+            this.ws.send(JSON.stringify({ type: 'stop' }));
+        }
+    }
+    close() {
+        this.closed = true;
+        try {
+            this.ws?.close();
+        }
+        catch { /* ignore */ }
+        this.ws = null;
+    }
+    handleMessage(e) {
+        let msg;
+        try {
+            msg = JSON.parse(typeof e.data === 'string' ? e.data : '');
+        }
+        catch {
+            return;
+        }
+        switch (msg.type) {
+            case 'providers':
+                this.callbacks.onProviders?.(msg.stt ?? '', msg.tts ?? '');
+                break;
+            case 'transcript-partial':
+                this.callbacks.onTranscriptPartial?.(msg.text ?? '');
+                break;
+            case 'transcript-final':
+                this.callbacks.onTranscriptFinal?.(msg.text ?? '');
+                break;
+            case 'task-created':
+                this.callbacks.onTaskCreated?.(msg.taskId ?? '');
+                break;
+            case 'task-result':
+                this.callbacks.onTaskResult?.(msg.taskId ?? '', msg.text ?? '', msg.status ?? '');
+                break;
+            case 'tts-frame': {
+                if (!msg.pcm)
+                    break;
+                const Buffer = loadBuffer();
+                const arr = new Uint8Array(Buffer.from(msg.pcm, 'base64'));
+                this.ttsChunks.push(arr);
+                this.ttsTotalBytes += arr.length;
+                if (msg.sampleRate)
+                    this.ttsSampleRate = msg.sampleRate;
+                break;
+            }
+            case 'done': {
+                if (this.ttsTotalBytes > 0) {
+                    const pcm = new Uint8Array(this.ttsTotalBytes);
+                    let off = 0;
+                    for (const c of this.ttsChunks) {
+                        pcm.set(c, off);
+                        off += c.length;
+                    }
+                    this.callbacks.onTTSReady?.(pcm, this.ttsSampleRate);
+                }
+                this.callbacks.onDone?.();
+                this.close();
+                break;
+            }
+            case 'error':
+                this.callbacks.onError?.(msg.error ?? 'voice error');
+                break;
+        }
+    }
+}
+exports.SDKVoiceSession = SDKVoiceSession;
+/** Wrap raw PCM (signed 16-bit LE) in a minimal WAV container for
+ *  expo-av playback. 44-byte header + samples. */
+function wrapPCMAsWAV(pcm, sampleRate, channels = 1) {
+    const bitsPerSample = 16;
+    const byteRate = (sampleRate * channels * bitsPerSample) / 8;
+    const blockAlign = (channels * bitsPerSample) / 8;
+    const dataSize = pcm.length;
+    const buf = new Uint8Array(44 + dataSize);
+    const dv = new DataView(buf.buffer);
+    buf[0] = 0x52;
+    buf[1] = 0x49;
+    buf[2] = 0x46;
+    buf[3] = 0x46; // RIFF
+    dv.setUint32(4, 36 + dataSize, true);
+    buf[8] = 0x57;
+    buf[9] = 0x41;
+    buf[10] = 0x56;
+    buf[11] = 0x45; // WAVE
+    buf[12] = 0x66;
+    buf[13] = 0x6d;
+    buf[14] = 0x74;
+    buf[15] = 0x20; // "fmt "
+    dv.setUint32(16, 16, true);
+    dv.setUint16(20, 1, true);
+    dv.setUint16(22, channels, true);
+    dv.setUint32(24, sampleRate, true);
+    dv.setUint32(28, byteRate, true);
+    dv.setUint16(32, blockAlign, true);
+    dv.setUint16(34, bitsPerSample, true);
+    buf[36] = 0x64;
+    buf[37] = 0x61;
+    buf[38] = 0x74;
+    buf[39] = 0x61; // data
+    dv.setUint32(40, dataSize, true);
+    buf.set(pcm, 44);
+    return buf;
+}
+/** Write a PCM buffer to a temp WAV file; returns its file:// URI. */
+async function pcmToTempWavURI(pcm, sampleRate) {
+    const Buffer = loadBuffer();
+    const FileSystem = loadFS();
+    const wav = wrapPCMAsWAV(pcm, sampleRate);
+    const b64 = Buffer.from(wav).toString('base64');
+    const dir = FileSystem.cacheDirectory ?? FileSystem.documentDirectory ?? '';
+    const path = `${dir}yaver-voice-tts-${Date.now()}.wav`;
+    await FileSystem.writeAsStringAsync(path, b64, { encoding: 'base64' });
+    return path;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.8.12",
-  "description": "Visual feedback SDK for Yaver \u2014 bug reports, screen recording, voice annotations, and local-first developer workflows",
+  "version": "0.9.0",
+  "description": "Visual feedback SDK for Yaver \u2014 bug reports, screen recording, voice vibe coding, and local-first developer workflows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -23,9 +23,23 @@
     "@react-native-async-storage/async-storage": ">=1.17.0",
     "expo-web-browser": ">=12.0.0",
     "expo-apple-authentication": ">=6.0.0",
-    "expo-document-picker": ">=13.0.0"
+    "expo-document-picker": ">=13.0.0",
+    "react-native-view-shot": ">=3.0.0",
+    "react-native-record-screen": ">=0.0.10",
+    "expo-av": ">=14.0.0",
+    "expo-file-system": ">=16.0.0",
+    "expo-speech": ">=12.0.0"
+  },
+  "dependencies": {
+    "buffer": "^6.0.3"
   },
   "peerDependenciesMeta": {
+    "expo-file-system": {
+      "optional": true
+    },
+    "expo-speech": {
+      "optional": true
+    },
     "@expo/config-plugins": {
       "optional": true
     },
@@ -37,6 +51,15 @@
     },
     "expo-document-picker": {
       "optional": true
+    },
+    "react-native-view-shot": {
+      "optional": true
+    },
+    "react-native-record-screen": {
+      "optional": true
+    },
+    "expo-av": {
+      "optional": true
     }
   },
   "devDependencies": {