@mentra/miniapp 0.3.0-dev.1 → 3.1.0-dev.4

package/src/hardware.ts

@@ -0,0 +1,25 @@
+/** Hardware components that a miniapp can declare in its manifest. */
+export enum HardwareType {
+  CAMERA = "CAMERA",
+  DISPLAY = "DISPLAY",
+  MICROPHONE = "MICROPHONE",
+  SPEAKER = "SPEAKER",
+  IMU = "IMU",
+  BUTTON = "BUTTON",
+  LIGHT = "LIGHT",
+  WIFI = "WIFI",
+  EXIST = "EXIST",
+}
+
+/** Whether a missing component prevents the miniapp from running. */
+export enum HardwareRequirementLevel {
+  REQUIRED = "REQUIRED",
+  OPTIONAL = "OPTIONAL",
+}
+
+/** One hardware requirement from a miniapp manifest. */
+export interface HardwareRequirement {
+  type: HardwareType
+  level: HardwareRequirementLevel
+  description?: string
+}

package/src/index.ts

@@ -36,14 +36,21 @@ export type {MentraOSGlobals, MiniappCapsuleMenuRect, MiniappColorScheme, Miniap
 
 export {MiniappErrorCode, MiniappRequestType, MiniappResponseType, MiniappStreamType} from "./protocol"
 export {CLOUD_STATUS_STREAM} from "./modules/cloud"
+
+// Language registry (issue 021): canonical language types + the validation
+// error the typed transcription/translation surfaces throw.
+export {
+  MiniappValidationError,
+  SUPPORTED_LANGUAGE_HINTS,
+  SUPPORTED_TRANSCRIPTION_LANGUAGES,
+  isTranscriptionLanguage,
+} from "./modules/languages"
+export type {LanguageHint, TranscriptionLanguage} from "./modules/languages"
 export type {CloudClientAudioTransport, CloudClientConnectionStatus, CloudClientStatus} from "./modules/cloud"
 
-// Hardware requirement types — re-exported from @mentra/types so miniapp
-// authors can type their miniapp.json manifest without pulling in the types
-// package directly. Keep explicit exports (enums as value, interfaces as
-// type) per @mentra/types' Bun-compat convention.
-export {HardwareType, HardwareRequirementLevel} from "@mentra/types"
-export type {HardwareRequirement} from "@mentra/types"
+// Canonical miniapp manifest hardware contract.
+export {HardwareType, HardwareRequirementLevel} from "./hardware"
+export type {HardwareRequirement} from "./hardware"
 
 // Transports — exported for advanced uses (forced transport injection, tests)
 export {createTransport} from "./transport/auto"
@@ -120,7 +127,14 @@ export type {
   StreamStatus,
   StreamVideoConfig,
 } from "./modules/stream"
-export type {ShareOptions, ShareResult, DownloadOptions, DownloadResult} from "./modules/system"
+export type {
+  ShareOptions,
+  ShareResult,
+  DownloadOptions,
+  DownloadResult,
+  ScanQrOptions,
+  ScanQrResult,
+} from "./modules/system"
 export type {MiniappInfo, MiniappActionInfo, MiniappCompatibility, ListMiniappsOptions} from "./modules/miniapps"
 export type {ActionContext, ActionHandler, InvokeOptions} from "./modules/actions"
 

package/src/modules/glasses.ts

@@ -41,4 +41,18 @@ export class GlassesModule {
       reason,
     })
   }
+
+  /**
+   * Enable or disable Wi-Fi ADB (wireless debugging) on Mentra Live.
+   * Persisted on the glasses; boot applies the saved preference (default off).
+   *
+   * SYSTEM-only — rejects with `NOT_PERMITTED` unless this miniapp is a system
+   * app. Third-party miniapps must not expose wireless debugging controls.
+   */
+  async setWifiAdbState(enabled: boolean): Promise<void> {
+    await this.session.sendRequest<void>({
+      type: MiniappRequestType.SET_WIFI_ADB_STATE,
+      enabled,
+    })
+  }
 }

package/src/modules/languages.ts

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview Language validation at the SDK boundary (issue 021, WP2).
+ *
+ * The registry itself lives in `@mentra/cloud-protocol/languages` (single
+ * source of truth shared with the cloud). This module re-exports the types so
+ * miniapps import everything from `@mentra/miniapp`, and adds the throwing
+ * validators the typed module surfaces (`transcription.*`, `translation.*`)
+ * call on every language parameter.
+ *
+ * Contract (design doc docs/issues/021-typed-language-subscriptions):
+ *   - Valid by construction: params are typed as literal unions, so TS users
+ *     get autocomplete and compile errors.
+ *   - Loud at runtime: JS users (or `any` casts) get a thrown
+ *     `MiniappValidationError` with a suggestion, never silent fallback.
+ *   - Canonical on the wire: bare codes ("fr") canonicalize to their default
+ *     tag ("fr-FR") before becoming stream keys, so the phone/cloud only ever
+ *     see registry tags.
+ */
+
+import {
+  isTranscriptionLanguage,
+  suggestTranscriptionLanguage,
+  toLanguageHint,
+  toTranscriptionLanguage,
+  SUPPORTED_LANGUAGE_HINTS,
+  SUPPORTED_TRANSCRIPTION_LANGUAGES,
+} from "@mentra/cloud-protocol/languages"
+import type {LanguageHint, TranscriptionLanguage} from "@mentra/cloud-protocol/languages"
+
+export {SUPPORTED_LANGUAGE_HINTS, SUPPORTED_TRANSCRIPTION_LANGUAGES, isTranscriptionLanguage}
+export type {LanguageHint, TranscriptionLanguage}
+
+/**
+ * Thrown synchronously by SDK methods when a parameter fails validation.
+ * Deliberately a hard throw (not a warning, not a silent default): an invalid
+ * language previously produced a subscription that silently transcribed the
+ * wrong language or silently never spoke (OS-1746).
+ */
+export class MiniappValidationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "MiniappValidationError"
+  }
+}
+
+/**
+ * Canonicalize a subscription language or throw. Accepts registry tags
+ * ("fr-FR") and bare registry codes ("fr" -> "fr-FR").
+ */
+export function requireTranscriptionLanguage(value: string, param: string): TranscriptionLanguage {
+  const canonical = toTranscriptionLanguage(value)
+  if (canonical) return canonical
+  const suggestion = suggestTranscriptionLanguage(value)
+  throw new MiniappValidationError(
+    `${param}: unknown language ${JSON.stringify(value)}` +
+      (suggestion ? ` — did you mean ${JSON.stringify(suggestion)}?` : "") +
+      ` Supported values are BCP-47 tags from SUPPORTED_TRANSCRIPTION_LANGUAGES (e.g. "en-US", "fr-FR").`,
+  )
+}
+
+/**
+ * Normalize a language hint to the bare code the STT provider accepts, or
+ * throw. Accepts bare codes ("fr") and registry tags ("fr-FR" -> "fr").
+ */
+export function requireLanguageHint(value: string, param: string): LanguageHint {
+  const hint = toLanguageHint(value)
+  if (hint) return hint
+  throw new MiniappValidationError(
+    `${param}: unknown language hint ${JSON.stringify(value)}. ` +
+      `Hints are bare ISO 639-1 codes from SUPPORTED_LANGUAGE_HINTS (e.g. "en", "fr").`,
+  )
+}

package/src/modules/mic.ts

@@ -15,7 +15,7 @@
  * PERMISSION_NOT_DECLARED otherwise.
  */
 
-import {MiniappStreamType} from "../protocol"
+import {MiniappRequestType, MiniappStreamType} from "../protocol"
 import {MiniappSession} from "../session"
 import type {AudioChunkData, UnsubscribeFn, VadData} from "./events"
 
@@ -41,6 +41,35 @@ export class MicModule {
     return this.track(this.session._subscribe(MiniappStreamType.AUDIO_CHUNK, handler as (data: unknown) => void))
   }
 
+  /**
+   * Temporarily override glasses-side voice activity detection (GX8002) for
+   * this miniapp's lifetime. When disabled, mic gating falls back to the
+   * loudness gate only (if it is enabled). The Mentra App's configured value
+   * is restored when this miniapp disconnects.
+   *
+   * Requires `MICROPHONE` in the miniapp manifest.
+   */
+  setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void> {
+    return this.session.sendRequest<void>({
+      type: MiniappRequestType.MIC_SET_VAD_ENABLED,
+      enabled,
+    })
+  }
+
+  /**
+   * Temporarily override the center-mic loudness gate ("Barrier") for this
+   * miniapp's lifetime. It blocks quiet/self-talk audio independent of VAD.
+   * The Mentra App's configured value is restored when this miniapp disconnects.
+   *
+   * Requires `MICROPHONE` in the miniapp manifest.
+   */
+  setLoudnessGateEnabled(enabled: boolean): Promise<void> {
+    return this.session.sendRequest<void>({
+      type: MiniappRequestType.MIC_SET_LOUDNESS_GATE_ENABLED,
+      enabled,
+    })
+  }
+
   /**
    * Tear down every subscription this module owns. Useful when a component
    * is unmounting and wants to free everything at once without tracking

package/src/modules/miniapps.ts

@@ -20,6 +20,8 @@ export interface MiniappActionInfo {
    * to an MCP tool `inputSchema`. Undefined for actions that take no params.
    */
   parameters?: Record<string, unknown>
+  /** JSON-Schema descriptor for the structured value returned by the action. */
+  outputSchema?: Record<string, unknown>
 }
 
 /**

package/src/modules/speaker.ts

@@ -50,6 +50,11 @@ export interface SpeakOptions {
   voice_settings?: Record<string, unknown>
   volume?: number
   stopOtherAudio?: boolean
+  /**
+   * Normalize display-oriented markup and symbols into natural spoken words.
+   * Defaults to true. Set false when exact characters must reach the TTS engine.
+   */
+  enableSanitization?: boolean
   /**
    * Force this call to use on-device offline TTS, skipping cloud TTS
    * entirely — even when cloud is connected. Rejects with `TTS_LOCAL_UNAVAILABLE`
@@ -253,9 +258,7 @@ export class SpeakerModule {
   async speak(text: string, options?: SpeakOptions): Promise<SpeakResult>
   async speak(sentences: string[], options?: SpeakOptions): Promise<SpeakResult>
   async speak(text: string | string[], options: SpeakOptions = {}): Promise<SpeakResult> {
-    const normalized = Array.isArray(text)
-      ? text.map((sentence) => sentence.trim()).filter(Boolean)
-      : text.trim()
+    const normalized = Array.isArray(text) ? text.map((sentence) => sentence.trim()).filter(Boolean) : text.trim()
     if ((Array.isArray(normalized) && normalized.length === 0) || normalized === "") {
       throw {code: MiniappErrorCode.INTERNAL, message: "speak requires at least one non-empty sentence"}
     }
@@ -271,6 +274,7 @@ export class SpeakerModule {
           voice_settings: options.voice_settings,
           volume: options.volume,
           stopOtherAudio: options.stopOtherAudio ?? false,
+          enableSanitization: options.enableSanitization ?? true,
           forceLocal: options.forceLocal ?? false,
         },
         {timeoutMs: 0},

package/src/modules/stream.ts

@@ -77,8 +77,12 @@ export interface StartStreamOptions {
    *     and automatic recording.
    *   - "whip": sub-second WebRTC playback (use `webrtcUrl`/WHEP), but no
    *     HLS/DASH and no recording.
+   *   - "rtmp": RTMPS ingest over TCP 443 → HLS playback. Use when WHIP/SRT
+   *     UDP is blocked (then play `hlsUrl`, not WHEP).
    */
-  ingest?: "srt" | "whip"
+  ingest?: "srt" | "whip" | "rtmp"
+  /** Optional Bearer token for direct WHIP Authorization (custom authenticated endpoints). */
+  authToken?: string
 }
 
 export interface StreamResult {
@@ -98,7 +102,7 @@ export interface StreamResult {
   webrtcUrl?: string
 }
 
-/** Live encoder telemetry, when the glasses emit it (no firmware does yet). */
+/** Live encoder and device telemetry emitted periodically by supported glasses firmware. */
 export interface StreamLiveStats {
   /** Current encoded video bitrate in bits per second. */
   bitrate?: number
@@ -141,6 +145,7 @@ export class StreamModule {
         video: options.video,
         audio: options.audio,
         sound: options.sound ?? true,
+        ...(options.authToken ? {authToken: options.authToken} : {}),
       })
     }
     return this.session.sendRequest<StreamResult>({

package/src/modules/system.ts

@@ -1,5 +1,5 @@
 /**
- * @fileoverview SystemModule — OS-level utilities (share, open URL, clipboard, download).
+ * @fileoverview SystemModule — OS-level utilities (share, open URL, clipboard, download, QR scan).
  *
  * These bridge to native phone capabilities via LocalMiniappRuntime.
  */
@@ -37,6 +37,15 @@ export interface DownloadResult {
   cancelled?: boolean
 }
 
+export interface ScanQrOptions {
+  /** Header title on the phone scanner overlay. */
+  title?: string
+  /** Hint shown over the camera viewfinder. */
+  hint?: string
+}
+
+export type ScanQrResult = {data: string; cancelled?: false} | {cancelled: true; data?: undefined}
+
 export class SystemModule {
   constructor(private readonly session: MiniappSession) {}
 
@@ -73,4 +82,20 @@ export class SystemModule {
     })
     return result ?? { success: false }
   }
+
+  /**
+   * Open the phone camera QR scanner as a host overlay. Does not unmount the
+   * miniapp (so live sessions survive the scan). Resolves with the raw QR
+   * payload, or `{cancelled: true}` if the user dismisses the scanner.
+   */
+  async scanQr(options: ScanQrOptions = {}): Promise<ScanQrResult> {
+    const result = await this.session.sendRequest<ScanQrResult>(
+      {
+        type: MiniappRequestType.SCAN_QR,
+        ...options,
+      },
+      {timeoutMs: 0},
+    )
+    return result ?? { cancelled: true }
+  }
 }

package/src/modules/transcription.ts

@@ -21,11 +21,18 @@
 import {MiniappRequestType, MiniappStreamType} from "../protocol"
 import {MiniappSession} from "../session"
 import type {TranscriptionData, UnsubscribeFn} from "./events"
+import {requireLanguageHint, requireTranscriptionLanguage} from "./languages"
+import type {LanguageHint, TranscriptionLanguage} from "./languages"
 
 /** Configuration for cloud-side transcription behavior. */
 export interface TranscriptionConfig {
-  /** ISO 639-1 language hints to improve detection accuracy (e.g. ["en", "ja"]). */
-  languageHints?: string[]
+  /**
+   * Language hints to improve auto-detection accuracy. Bare ISO 639-1 codes
+   * from the registry (e.g. ["en", "ja"]); registry BCP-47 tags are accepted
+   * and normalized ("en-US" -> "en"). Anything else throws
+   * `MiniappValidationError`.
+   */
+  languageHints?: LanguageHint[]
   /** Custom vocabulary / boosted terms (e.g. ["MentraOS", "HIPAA"]). */
   vocabulary?: string[]
   /** Enable speaker diarisation. Defaults vary by provider. */
@@ -65,15 +72,24 @@ export class TranscriptionModule {
    * Subscribe to transcription for one or more specific languages. Each call
    * is independent; multiple can be active simultaneously.
    *
-   * @param language - BCP-47 tag(s), e.g. `"en-US"` or `["en-US", "es-ES"]`.
+   * Languages are validated against the platform registry
+   * (`SUPPORTED_TRANSCRIPTION_LANGUAGES`): registry BCP-47 tags pass through,
+   * bare registry codes canonicalize ("fr" -> "fr-FR"), anything else throws
+   * `MiniappValidationError` immediately — an invalid language must never
+   * become a subscription that silently transcribes the wrong thing
+   * (OS-1746 / issue 021).
+   *
+   * @param language - Registry tag(s), e.g. `"en-US"` or `["en-US", "es-ES"]`.
    * @param handler  - Called for every event in any of the listed languages.
    */
   forLanguage(
-    language: string | string[],
+    language: TranscriptionLanguage | TranscriptionLanguage[],
     handler: (data: TranscriptionData) => void,
     options: TranscriptionOptions = {},
   ): UnsubscribeFn {
-    const langs = Array.isArray(language) ? language : [language]
+    const langs = (Array.isArray(language) ? language : [language]).map((lang) =>
+      requireTranscriptionLanguage(lang, "transcription.forLanguage(language)"),
+    )
     if (langs.length === 0) return () => {}
 
     const unsubs: UnsubscribeFn[] = []
@@ -100,15 +116,29 @@ export class TranscriptionModule {
 
   /**
    * Apply transcription configuration (language hints, custom vocabulary,
-   * diarisation toggle). Sent to the cloud immediately. Cached locally so we
-   * could re-send on reconnect (future).
+   * diarisation toggle). Hints are validated against the registry and
+   * normalized to bare codes ("en-US" -> "en"); unknown values throw
+   * `MiniappValidationError` synchronously.
+   *
+   * Sent to the phone runtime as a REQUEST (not a one-shot) so the returned
+   * promise rejects if the runtime cannot apply it — a config that the
+   * platform ignores must be loud, not silent (issue 021 S3). Cached locally
+   * so the runtime can re-apply on reconnect.
    */
-  configure(config: TranscriptionConfig): void {
-    this.currentConfig = {...config}
-    this.session.sendOneShot({
-      type: MiniappRequestType.TRANSCRIPTION_CONFIG,
-      config: {...config},
-    })
+  configure(config: TranscriptionConfig): Promise<void> {
+    const normalized: TranscriptionConfig = {
+      ...config,
+      languageHints: config.languageHints?.map((hint) =>
+        requireLanguageHint(hint, "transcription.configure(languageHints)"),
+      ),
+    }
+    this.currentConfig = {...normalized}
+    return this.session
+      .sendRequest<void>({
+        type: MiniappRequestType.TRANSCRIPTION_CONFIG,
+        config: {...normalized},
+      })
+      .then(() => undefined)
   }
 
   /** Tear down every transcription subscription this module owns. */

package/src/modules/translation.ts

@@ -20,9 +20,17 @@
 import {MiniappStreamType} from "../protocol"
 import {MiniappSession} from "../session"
 import type {TranslationData, UnsubscribeFn} from "./events"
+import {requireTranscriptionLanguage} from "./languages"
+import type {TranscriptionLanguage} from "./languages"
 
 export type TranslationHandler = (data: TranslationData) => void
 
+/**
+ * Translation source: a registry language, or "auto" to let the cloud detect
+ * the spoken language.
+ */
+export type TranslationSource = TranscriptionLanguage | "auto"
+
 export class TranslationModule {
   private readonly unsubs = new Set<UnsubscribeFn>()
 
@@ -51,8 +59,10 @@ export class TranslationModule {
    * regardless of source. Useful for "I'm a Spanish speaker, translate
    * whatever I hear to Spanish."
    */
-  to(target: string | string[], handler: TranslationHandler): UnsubscribeFn {
-    const targets = Array.isArray(target) ? target : [target]
+  to(target: TranscriptionLanguage | TranscriptionLanguage[], handler: TranslationHandler): UnsubscribeFn {
+    const targets = (Array.isArray(target) ? target : [target]).map((t) =>
+      requireTranscriptionLanguage(t, "translation.to(target)"),
+    )
     if (targets.length === 0) return () => {}
     const unsubs: UnsubscribeFn[] = []
     for (const t of targets) {
@@ -81,17 +91,21 @@ export class TranslationModule {
    * from the same source.
    */
   fromTo(
-    source: string,
-    target: string | string[],
+    source: TranslationSource,
+    target: TranscriptionLanguage | TranscriptionLanguage[],
     handler: TranslationHandler,
   ): UnsubscribeFn {
-    const targets = Array.isArray(target) ? target : [target]
+    const validSource =
+      source === "auto" ? "auto" : requireTranscriptionLanguage(source, "translation.fromTo(source)")
+    const targets = (Array.isArray(target) ? target : [target]).map((t) =>
+      requireTranscriptionLanguage(t, "translation.fromTo(target)"),
+    )
     if (targets.length === 0) return () => {}
     const unsubs: UnsubscribeFn[] = []
     for (const t of targets) {
       unsubs.push(
         this.session._subscribe(
-          `${MiniappStreamType.TRANSLATION}:${source}:${t}`,
+          `${MiniappStreamType.TRANSLATION}:${validSource}:${t}`,
           handler as (data: unknown) => void,
         ),
       )
@@ -113,8 +127,8 @@ export class TranslationModule {
    * SDK v3 parity. This alias will be removed in a future release.
    */
   forLanguagePair(
-    fromLang: string,
-    toLang: string,
+    fromLang: TranslationSource,
+    toLang: TranscriptionLanguage,
     handler: TranslationHandler,
   ): UnsubscribeFn {
     return this.fromTo(fromLang, toLang, handler)

package/src/protocol.ts

@@ -117,6 +117,17 @@ export enum MiniappRequestType {
    */
   IMU_SET_ENABLED = "miniapp_imu_set_enabled",
 
+  /** Explicitly enable/disable glasses-side VAD (GX8002). Mirrors the app's mic settings toggle. */
+  MIC_SET_VAD_ENABLED = "miniapp_mic_set_vad_enabled",
+  /** Explicitly enable/disable the center-mic loudness gate ("Barrier"). */
+  MIC_SET_LOUDNESS_GATE_ENABLED = "miniapp_mic_set_loudness_gate_enabled",
+
+  /**
+   * Enable or disable Wi-Fi ADB (wireless debugging) on Mentra Live.
+   * SYSTEM-only — host rejects with NOT_PERMITTED for non-system callers.
+   */
+  SET_WIFI_ADB_STATE = "miniapp_set_wifi_adb_state",
+
   /** Share content via the OS share sheet. */
   SHARE = "miniapp_share",
   /** Open a URL in the system browser. */
@@ -125,6 +136,11 @@ export enum MiniappRequestType {
   COPY_CLIPBOARD = "miniapp_copy_clipboard",
   /** Download a file (triggers OS share sheet for save location). */
   DOWNLOAD = "miniapp_download",
+  /**
+   * Open a phone-camera QR scanner overlay. Host must not unmount the miniapp
+   * (clearing foreground fires UI_CLOSE and can hang up live sessions).
+   */
+  SCAN_QR = "miniapp_scan_qr",
 
   /**
    * Phone-local persistent binary blob storage, scoped to (userId, packageName).
@@ -343,7 +359,10 @@ export enum MiniappErrorCode {
   NOT_CONNECTED = "NOT_CONNECTED",
 
   // ----- Inter-miniapp interop -----
-  /** Caller is not a system app — interop APIs (list/start/stop/invoke) are SYSTEM-only. */
+  /**
+   * Caller is not a system app — SYSTEM-only APIs (interop list/start/stop/invoke,
+   * setWifiAdbState) reject with this code.
+   */
   NOT_PERMITTED = "NOT_PERMITTED",
   /** Target miniapp is not installed. */
   APP_NOT_FOUND = "APP_NOT_FOUND",

package/src/react/capsuleHeaderLayout.ts

@@ -0,0 +1,11 @@
+import type {MiniappCapsuleMenuRect} from "../globals"
+
+export function getCapsuleHeaderPaddingRight(
+  capsuleMenu: MiniappCapsuleMenuRect,
+  viewportWidth: number,
+  safeAreaRight: number,
+  rightGap: number,
+): number {
+  const capsuleOffsetFromContentRight = viewportWidth - capsuleMenu.left - safeAreaRight
+  return Math.max(rightGap, capsuleOffsetFromContentRight + rightGap)
+}

package/src/react/useCapsuleHeaderStyle.ts

@@ -15,6 +15,7 @@
 
 import type {CSSProperties} from "react"
 
+import {getCapsuleHeaderPaddingRight} from "./capsuleHeaderLayout"
 import {useSafeArea} from "./useSafeArea"
 
 export interface UseCapsuleHeaderStyleOptions {
@@ -39,7 +40,11 @@ export function useCapsuleHeaderStyle(
     ? capsuleMenu.top + capsuleMenu.height / 2 - insets.top
     : fallbackMarginTop + height / 2
   const marginTop = Math.max(0, center - height / 2)
-  const paddingRight = capsuleMenu ? capsuleMenu.width + rightGap : leftPadding
+  const paddingRight = capsuleMenu
+    ? typeof window === "undefined"
+      ? capsuleMenu.width + rightGap
+      : getCapsuleHeaderPaddingRight(capsuleMenu, window.innerWidth, insets.right, rightGap)
+    : leftPadding
 
   return {
     display: "flex",

package/src/transport/mock.ts

@@ -243,8 +243,12 @@ function syntheticDataFor(requestId: string, requestType: string, requestPayload
     case MiniappRequestType.COPY_CLIPBOARD:
     case MiniappRequestType.DOWNLOAD:
     case MiniappRequestType.REQUEST_WIFI_SETUP:
+    case MiniappRequestType.SET_WIFI_ADB_STATE:
       return {ok: true}
 
+    case MiniappRequestType.SCAN_QR:
+      return {cancelled: true}
+
     default:
       return null
   }