@elizaos/capacitor-screencapture 2.0.0-beta.1 → 2.0.3-beta.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shaw Walters and elizaOS Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# @elizaos/capacitor-screencapture
+
+Cross-platform screen capture Capacitor plugin for elizaOS. Captures screenshots and records the screen on browser (Web API), iOS (ReplayKit + AVFoundation), and Android (MediaProjection).
+
+## What it does
+
+- **Screenshot:** Captures a single frame of the screen as a base64-encoded PNG, JPEG, or WebP image.
+- **Screen recording:** Records the screen to a video file (WebM on browser, MP4 on native), with optional audio from the system, microphone, or both.
+- **Pause / resume:** Pause and resume an active recording without creating a new file (Android requires API 24+).
+- **Permission checks:** Query and request screen-capture and microphone permissions in a unified cross-platform API.
+- **Live events:** Subscribe to `recordingState` and `error` events emitted during recording.
+
+## Platform support
+
+| Feature | Browser | iOS | Android |
+|---------|---------|-----|---------|
+| Screenshot | Yes (getDisplayMedia) | Yes (UIKit) | Yes (MediaProjection) |
+| Screen recording | Yes (MediaRecorder) | Yes (ReplayKit) | Yes (MediaRecorder) |
+| Pause/resume | Yes | Yes | API 24+ only |
+| System audio | Browser-dependent | Yes (RPSampleBufferType.audioApp) | No (microphone only) |
+| Microphone audio | Yes | Yes | Yes |
+
+## Installation
+
+```bash
+npm install @elizaos/capacitor-screencapture
+npx cap sync
+```
+
+For iOS, add to your app's `Info.plist`:
+```xml
+<key>NSMicrophoneUsageDescription</key>
+<string>Microphone is used to capture audio during screen recording.</string>
+```
+
+For Android 14+ (API 34), declare in `AndroidManifest.xml`:
+```xml
+<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+```
+This is in addition to the `FOREGROUND_SERVICE` permission that this plugin's own `AndroidManifest.xml` already declares.
+
+## Usage
+
+```typescript
+import { ScreenCapture } from '@elizaos/capacitor-screencapture';
+
+// Check support
+const { supported, features } = await ScreenCapture.isSupported();
+
+// Take a screenshot
+const shot = await ScreenCapture.captureScreenshot({ format: 'png', quality: 100 });
+// shot.base64 contains the image data
+
+// Record the screen
+await ScreenCapture.startRecording({
+  quality: 'high',        // 'low' | 'medium' | 'high' | 'highest'
+  fps: 30,
+  captureSystemAudio: true,
+  captureMicrophone: false,
+  maxDuration: 300,       // seconds; undefined = unlimited
+});
+
+// Listen for state updates
+const handle = await ScreenCapture.addListener('recordingState', (state) => {
+  console.log(`Recording: ${state.isRecording}, duration: ${state.duration}s`);
+});
+
+// Stop and get the result
+const result = await ScreenCapture.stopRecording();
+// result.path — blob: URL (browser) or filesystem path (native)
+// result.mimeType — video/webm (browser) or video/mp4 (native)
+
+await handle.remove();
+```
+
+## Permissions
+
+Screen capture permission works differently per platform:
+
+- **Browser:** `getDisplayMedia` always shows an OS-level picker dialog. There is no way to pre-grant or query this permission. `checkPermissions()` returns `"prompt"` when the API is available.
+- **iOS:** Screenshots use UIKit only — no permission required. `startRecording` uses ReplayKit, which shows a system broadcast picker on first use.
+- **Android:** `captureScreenshot` and `startRecording` both trigger a `MediaProjection` consent dialog. Microphone permission (`RECORD_AUDIO`) is requested at runtime when `captureMicrophone: true`.
+
+```typescript
+// Check permissions
+const status = await ScreenCapture.checkPermissions();
+// status.screenCapture: 'granted' | 'denied' | 'prompt' | 'not_supported'
+// status.microphone:    'granted' | 'denied' | 'prompt'
+
+// Request microphone permission before recording with audio
+await ScreenCapture.requestPermissions();
+```
+
+## Output formats
+
+| Platform | Screenshot | Recording |
+|----------|-----------|-----------|
+| Browser  | PNG / JPEG / WebP | video/webm (VP9 preferred), blob: URL |
+| iOS      | PNG / JPEG / WebP (WebP requires iOS 14+) | video/mp4 (H.264 + AAC), file:// path |
+| Android  | PNG / JPEG / WebP (WebP lossy requires API 30+) | video/mp4 (H.264), file path |
+
+## Recording options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `quality` | `'low' \| 'medium' \| 'high' \| 'highest'` | `'high'` | Quality preset (sets bitrate on iOS; sets fps + bitrate on Android) |
+| `fps` | `number` | 30 | Frames per second (1–60; overrides quality preset) |
+| `bitrate` | `number` | Estimated | Video bitrate in bits/s (overrides quality preset) |
+| `maxDuration` | `number` | unlimited | Stop automatically after N seconds |
+| `maxFileSize` | `number` | unlimited | Stop automatically after N bytes |
+| `captureSystemAudio` | `boolean` | `true` | Include app/system audio (browser + iOS; Android records microphone only) |
+| `captureMicrophone` | `boolean` | `false` | Include microphone audio in recording |
+
+## Building from source
+
+```bash
+bun run --cwd plugins/plugin-native-screencapture build
+```
+
+This runs `tsc` then `rollup` and outputs `dist/esm/`, `dist/plugin.js` (IIFE), and `dist/plugin.cjs.js`.

package/android/build.gradle

@@ -7,6 +7,16 @@ ext {
 }
 
 apply plugin: 'com.android.library'
+// Explicitly apply the Kotlin Android plugin. The kotlin-gradle-plugin is on
+// the root buildscript classpath, but without applying it here AGP 8.13 falls
+// back to its "built-in Kotlin" compile path (build/intermediates/
+// built_in_kotlinc), which compiles the .kt sources but does NOT bundle the
+// resulting .class files into the *release* library jar. The app's
+// :app:assembleRelease then links a library AAR with zero plugin classes, so
+// the Capacitor plugin (and any manifest-declared component) is absent from
+// the release dex. Applying the standard Kotlin plugin wires Kotlin
+// compilation into both the debug and release jar-bundling tasks.
+apply plugin: 'org.jetbrains.kotlin.android'
 android {
     namespace = "ai.eliza.plugins.screencapture"
     compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
@@ -25,8 +35,12 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_17
-        targetCompatibility JavaVersion.VERSION_17
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+
+    kotlinOptions {
+        jvmTarget = "21"
     }
 
 }

package/android/src/main/AndroidManifest.xml

@@ -3,4 +3,13 @@
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" android:minSdkVersion="34" />
+
+    <application>
+        <!-- Android 14+ requires a running mediaProjection FGS before
+             getMediaProjection(); the plugin starts/stops this around a capture. -->
+        <service
+            android:name="ai.eliza.plugins.screencapture.ScreenCaptureFgService"
+            android:exported="false"
+            android:foregroundServiceType="mediaProjection" />
+    </application>
 </manifest>

package/android/src/main/java/ai/eliza/plugins/screencapture/ScreenCaptureFgService.kt

@@ -0,0 +1,59 @@
+package ai.eliza.plugins.screencapture
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+
+/**
+ * Foreground service of type `mediaProjection`. Android 14+ (API 34) throws
+ *   SecurityException: Media projections require a foreground service of type
+ *   ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
+ * from `MediaProjectionManager.getMediaProjection()` unless such a service is
+ * already running. The screencapture plugin starts this service immediately
+ * after the user grants the projection consent and stops it when the projection
+ * is released, so a single screenshot / continuous capture works on Android 14+.
+ */
+class ScreenCaptureFgService : Service() {
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val channelId = "eliza_screen_capture"
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val nm = getSystemService(NotificationManager::class.java)
+            if (nm != null && nm.getNotificationChannel(channelId) == null) {
+                nm.createNotificationChannel(
+                    NotificationChannel(
+                        channelId,
+                        "Screen capture",
+                        NotificationManager.IMPORTANCE_LOW
+                    )
+                )
+            }
+        }
+        val notification: Notification = Notification.Builder(this, channelId)
+            .setContentTitle("Screen sharing active")
+            .setContentText("This app is reading the screen.")
+            .setSmallIcon(android.R.drawable.ic_menu_camera)
+            .setOngoing(true)
+            .build()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(
+                NOTIF_ID,
+                notification,
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
+            )
+        } else {
+            startForeground(NOTIF_ID, notification)
+        }
+        return START_NOT_STICKY
+    }
+
+    companion object {
+        const val NOTIF_ID = 8451
+    }
+}

package/android/src/main/java/ai/eliza/plugins/screencapture/ScreenCapturePlugin.kt

@@ -7,6 +7,7 @@ import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.content.Context
 import android.content.Intent
+import androidx.core.content.ContextCompat
 import android.graphics.Bitmap
 import android.graphics.PixelFormat
 import android.hardware.display.DisplayManager
@@ -57,6 +58,10 @@ class ScreenCapturePlugin : Plugin() {
     private var virtualDisplay: VirtualDisplay? = null
     private var mediaRecorder: MediaRecorder? = null
     private var imageReader: ImageReader? = null
+    // Dimensions of the warm screenshot VirtualDisplay, so repeated captures at
+    // the same scale reuse it instead of re-creating it each frame.
+    private var screenshotVdWidth = 0
+    private var screenshotVdHeight = 0
 
     // Recording state
     private var isRecording = false
@@ -153,6 +158,17 @@ class ScreenCapturePlugin : Plugin() {
         pendingCall = call
         pendingAction = "screenshot"
 
+        // Reuse an already-granted session projection instead of re-prompting
+        // the system consent dialog on every capture. Continuous screen
+        // understanding (EPIC #9105) captures repeatedly; tearing the projection
+        // down + re-consenting per frame is a battery/latency/UX killer. The
+        // projection is kept warm across captures and only released on
+        // background/destroy or when the system stops it.
+        if (mediaProjection != null) {
+            captureScreenshotInternal(call)
+            return
+        }
+
         val intent = mediaProjectionManager?.createScreenCaptureIntent()
         if (intent != null) {
             startActivityForResult(call, intent, "handleProjectionResult")
@@ -339,27 +355,69 @@ class ScreenCapturePlugin : Plugin() {
             return
         }
 
-        mediaProjection = mediaProjectionManager?.getMediaProjection(result.resultCode, result.data!!)
-
-        if (mediaProjection == null) {
-            call.reject("Failed to get media projection")
-            return
+        // Android 14+ (API 34) throws SecurityException from getMediaProjection()
+        // unless a foreground service of type mediaProjection is ALREADY running.
+        // Start it now, then acquire the projection once it has gone foreground.
+        try {
+            ContextCompat.startForegroundService(
+                context,
+                Intent(context, ScreenCaptureFgService::class.java)
+            )
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not start mediaProjection FGS", e)
         }
 
-        // Register stop callback for cleanup
-        mediaProjection?.registerCallback(object : MediaProjection.Callback() {
-            override fun onStop() {
-                Log.d(TAG, "MediaProjection stopped by system")
-                if (isRecording) {
-                    scope.launch { stopRecordingInternal() }
+        Handler(Looper.getMainLooper()).postDelayed({
+            try {
+                mediaProjection =
+                    mediaProjectionManager?.getMediaProjection(result.resultCode, result.data!!)
+            } catch (e: Exception) {
+                Log.e(TAG, "getMediaProjection failed", e)
+                stopFgService()
+                call.reject("Media projection failed: ${e.message}")
+                return@postDelayed
+            }
+            if (mediaProjection == null) {
+                stopFgService()
+                call.reject("Failed to get media projection")
+                return@postDelayed
+            }
+
+            // Register stop callback for cleanup
+            mediaProjection?.registerCallback(object : MediaProjection.Callback() {
+                override fun onStop() {
+                    Log.d(TAG, "MediaProjection stopped by system")
+                    if (isRecording) {
+                        scope.launch { stopRecordingInternal() }
+                    }
+                    // The session projection is gone — drop our warm references so
+                    // the next captureScreenshot re-acquires consent cleanly instead
+                    // of using a dead projection.
+                    virtualDisplay?.release()
+                    virtualDisplay = null
+                    imageReader?.close()
+                    imageReader = null
+                    screenshotVdWidth = 0
+                    screenshotVdHeight = 0
+                    mediaProjection = null
+                    stopFgService()
                 }
+            }, Handler(Looper.getMainLooper()))
+
+            when (pendingAction) {
+                "screenshot" -> captureScreenshotInternal(call)
+                "recording" -> startRecordingInternal(call)
+                else -> call.reject("Unknown action")
             }
-        }, Handler(Looper.getMainLooper()))
+        }, 600)
+    }
 
-        when (pendingAction) {
-            "screenshot" -> captureScreenshotInternal(call)
-            "recording" -> startRecordingInternal(call)
-            else -> call.reject("Unknown action")
+    /** Stop the mediaProjection foreground service (idempotent). */
+    private fun stopFgService() {
+        try {
+            context.stopService(Intent(context, ScreenCaptureFgService::class.java))
+        } catch (e: Exception) {
+            Log.w(TAG, "stopFgService failed", e)
         }
     }
 
@@ -370,23 +428,38 @@ class ScreenCapturePlugin : Plugin() {
         val quality = call.getInt("quality") ?: 100
         val scale = call.getFloat("scale") ?: 1f
 
-        val width = (screenWidth * scale).toInt()
-        val height = (screenHeight * scale).toInt()
-
-        imageReader = ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 2)
-
-        virtualDisplay = mediaProjection?.createVirtualDisplay(
-            "ScreenCapture",
-            width,
-            height,
-            screenDensity,
-            DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
-            imageReader?.surface,
-            null,
-            null
-        )
+        val width = Math.max(1, (screenWidth * scale).toInt())
+        val height = Math.max(1, (screenHeight * scale).toInt())
+
+        // Reuse the warm VirtualDisplay + ImageReader when the requested size
+        // matches; only (re)create them when missing or the scale changed. The
+        // resize itself is native — the VirtualDisplay renders directly at the
+        // target resolution, so the agent never resizes pixels in JS.
+        val warm = virtualDisplay != null &&
+            imageReader != null &&
+            screenshotVdWidth == width &&
+            screenshotVdHeight == height
+        if (!warm) {
+            virtualDisplay?.release()
+            imageReader?.close()
+            imageReader = ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 2)
+            virtualDisplay = mediaProjection?.createVirtualDisplay(
+                "ScreenCapture",
+                width,
+                height,
+                screenDensity,
+                DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
+                imageReader?.surface,
+                null,
+                null
+            )
+            screenshotVdWidth = width
+            screenshotVdHeight = height
+        }
 
-        // Brief delay to allow the VirtualDisplay to render a frame
+        // A freshly-created mirror needs ~250ms to render its first frame; a warm
+        // display is already mirroring continuously, so a short settle suffices.
+        val settleMs = if (warm) 60L else 250L
         Handler(Looper.getMainLooper()).postDelayed({
             try {
                 val image = imageReader?.acquireLatestImage()
@@ -412,7 +485,9 @@ class ScreenCapturePlugin : Plugin() {
 
                     val base64 = Base64.encodeToString(outputStream.toByteArray(), Base64.NO_WRAP)
 
-                    cleanup()
+                    // Keep the projection + VirtualDisplay warm for the next
+                    // capture — do NOT cleanup() here (that stopped the
+                    // projection and forced a re-consent every frame).
 
                     call.resolve(JSObject().apply {
                         put("base64", base64)
@@ -422,16 +497,36 @@ class ScreenCapturePlugin : Plugin() {
                         put("timestamp", System.currentTimeMillis())
                     })
                 } else {
-                    cleanup()
+                    // Transient empty frame — keep the session warm, just fail
+                    // this one capture so the caller can retry on the next tick.
                     call.reject("Failed to capture screenshot")
                 }
             } catch (e: Exception) {
                 Log.e(TAG, "Screenshot capture failed", e)
-                cleanup()
+                // A real error may have invalidated the projection — tear it all
+                // down so the next capture re-acquires cleanly.
+                releaseProjection()
                 notifyError("screenshot_failed", "Screenshot failed: ${e.message}")
                 call.reject("Screenshot failed: ${e.message}")
             }
-        }, 250) // 250ms delay to ensure frame is rendered
+        }, settleMs)
+    }
+
+    /**
+     * Full teardown of the warm screenshot projection + its mirror. Use on
+     * background/destroy or after an error invalidates the session. Recording
+     * has its own lifecycle via [cleanup].
+     */
+    private fun releaseProjection() {
+        virtualDisplay?.release()
+        virtualDisplay = null
+        imageReader?.close()
+        imageReader = null
+        screenshotVdWidth = 0
+        screenshotVdHeight = 0
+        mediaProjection?.stop()
+        mediaProjection = null
+        stopFgService()
     }
 
     private fun imageToBitmap(image: Image, width: Int, height: Int): Bitmap {
@@ -755,11 +850,28 @@ class ScreenCapturePlugin : Plugin() {
         virtualDisplay = null
         imageReader?.close()
         imageReader = null
+        screenshotVdWidth = 0
+        screenshotVdHeight = 0
         mediaProjection?.stop()
         mediaProjection = null
+        stopFgService()
     }
 
-    // ── Destroy ─────────────────────────────────────────────────────────
+    // ── Lifecycle ───────────────────────────────────────────────────────
+
+    override fun handleOnStop() {
+        super.handleOnStop()
+        // Release the warm screenshot MediaProjection when the app is no longer
+        // visible. A backgrounded app must not hold a live screen-capture
+        // session — it drains battery, keeps the system cast/record indicator
+        // up, and is a privacy concern. (handleOnStop fires on full background,
+        // not the transient pause the consent dialog causes, so it won't tear
+        // down a projection mid-acquisition.) Recording owns its own projection
+        // lifecycle, so leave it alone while a recording is active.
+        if (!isRecording) {
+            releaseProjection()
+        }
+    }
 
     override fun handleOnDestroy() {
         super.handleOnDestroy()

package/dist/esm/web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EACV,uBAAuB,EACvB,6BAA6B,EAC7B,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAEvB,KAAK,sBAAsB,GAAG,oBAAoB,GAAG,uBAAuB,CAAC;AA4B7E,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,kBAAkB,CAAK;IAC/B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,sBAAsB,CAA+C;IAC7E,OAAO,CAAC,eAAe,CAGf;IAEF,WAAW,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IASlE,iBAAiB,CACrB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,gBAAgB,CAAC;IA0DtB,cAAc,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmG/D,aAAa,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAuE/C,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B/B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAchC,iBAAiB,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAgBxD;;;;;;;;;;OAUG;IACG,gBAAgB,IAAI,OAAO,CAAC,6BAA6B,CAAC;IAiBhE;;;;;;;;;;OAUG;IACG,kBAAkB,IAAI,OAAO,CAAC,6BAA6B,CAAC;IAkB5D,WAAW,CACf,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,GACpD,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;IAWrC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzC,SAAS,CAAC,eAAe,CACvB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,sBAAsB,GAC3B,IAAI;CAOR"}
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EACV,uBAAuB,EACvB,6BAA6B,EAC7B,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAEvB,KAAK,sBAAsB,GAAG,oBAAoB,GAAG,uBAAuB,CAAC;AAiD7E,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,kBAAkB,CAAK;IAC/B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,sBAAsB,CAA+C;IAC7E,OAAO,CAAC,eAAe,CAGf;IAEF,WAAW,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IASlE,iBAAiB,CACrB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,gBAAgB,CAAC;IAgEtB,cAAc,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IA+G/D,aAAa,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAuE/C,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B/B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAchC,iBAAiB,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAgBxD;;;;;;;;;;OAUG;IACG,gBAAgB,IAAI,OAAO,CAAC,6BAA6B,CAAC;IAiBhE;;;;;;;;;;OAUG;IACG,kBAAkB,IAAI,OAAO,CAAC,6BAA6B,CAAC;IAkB5D,WAAW,CACf,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,GACpD,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;IAWrC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzC,SAAS,CAAC,eAAe,CACvB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,sBAAsB,GAC3B,IAAI;CAOR"}

package/dist/esm/web.js

@@ -5,8 +5,28 @@ const VIDEO_MIME_TYPES = [
     "video/webm",
     "video/mp4",
 ];
-const getSupportedMimeType = () => VIDEO_MIME_TYPES.find((m) => MediaRecorder.isTypeSupported(m)) ?? null;
-const hasDisplayMedia = () => !!navigator.mediaDevices.getDisplayMedia;
+const getSupportedMimeType = () => typeof MediaRecorder === "undefined"
+    ? null
+    : (VIDEO_MIME_TYPES.find((m) => MediaRecorder.isTypeSupported(m)) ?? null);
+const hasDisplayMedia = () => !!navigator.mediaDevices
+    ?.getDisplayMedia;
+function assertPositiveFiniteNumber(value, label) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        throw new Error(`${label} must be a positive finite number`);
+    }
+    return value;
+}
+function assertQuality(value) {
+    if (value === undefined)
+        return 1;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error("quality must be a finite number between 0 and 100");
+    }
+    if (value < 0 || value > 100) {
+        throw new Error("quality must be between 0 and 100");
+    }
+    return value / 100;
+}
 const getDisplayMedia = (opts) => navigator.mediaDevices.getDisplayMedia(opts);
 export class ScreenCaptureWeb extends WebPlugin {
     constructor() {
@@ -35,8 +55,10 @@ export class ScreenCaptureWeb extends WebPlugin {
     }
     async captureScreenshot(options) {
         const format = options?.format || "png";
-        const quality = (options?.quality || 100) / 100;
-        const scale = options?.scale || 1;
+        const quality = assertQuality(options?.quality);
+        const scale = options?.scale === undefined
+            ? 1
+            : assertPositiveFiniteNumber(options.scale, "scale");
         // PERMISSIONS_MIGRATION: getDisplayMedia() triggers the OS screen
         // recording / picker dialog implicitly. New flow probes via
         // `screenRecordingProber` in
@@ -51,11 +73,16 @@ export class ScreenCaptureWeb extends WebPlugin {
         const settings = track.getSettings();
         const width = (settings.width || 1920) * scale;
         const height = (settings.height || 1080) * scale;
-        const imageCapture = new ImageCapture(track);
-        const bitmap = await imageCapture.grabFrame();
-        stream.getTracks().forEach((t) => {
-            t.stop();
-        });
+        let bitmap = null;
+        try {
+            const imageCapture = new ImageCapture(track);
+            bitmap = await imageCapture.grabFrame();
+        }
+        finally {
+            stream.getTracks().forEach((t) => {
+                t.stop();
+            });
+        }
         const canvas = document.createElement("canvas");
         canvas.width = width;
         canvas.height = height;
@@ -83,6 +110,18 @@ export class ScreenCaptureWeb extends WebPlugin {
     async startRecording(options) {
         if (this.isRecording)
             throw new Error("Recording already in progress");
+        if (options?.fps !== undefined) {
+            assertPositiveFiniteNumber(options.fps, "fps");
+        }
+        if (options?.bitrate !== undefined) {
+            assertPositiveFiniteNumber(options.bitrate, "bitrate");
+        }
+        if (options?.maxDuration !== undefined) {
+            assertPositiveFiniteNumber(options.maxDuration, "maxDuration");
+        }
+        if (options?.maxFileSize !== undefined) {
+            assertPositiveFiniteNumber(options.maxFileSize, "maxFileSize");
+        }
         const videoConstraints = {
             displaySurface: "monitor",
         };

package/dist/esm/web.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=web.test.d.ts.map

package/dist/esm/web.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.test.d.ts","sourceRoot":"","sources":["../../src/web.test.ts"],"names":[],"mappings":""}