react-native-webrtc-kaleidoscope 2.0.0 → 2.1.1

package/android/src/main/java/com/simiancraft/kaleidoscope/segmentation/SegmentationEngine.kt

@@ -38,111 +38,117 @@ import java.nio.ByteBuffer
 import java.nio.ByteOrder
 
 internal object SegmentationEngine {
-  private const val TAG = "Kaleidoscope.SegEngine"
+    private const val TAG = "Kaleidoscope.SegEngine"
 
-  // Lazy, process-lived. Created on first submit, never torn down.
-  private val workerThread: HandlerThread by lazy {
-    HandlerThread("Kaleidoscope.MaskWorker").also { it.start() }
-  }
-  private val workerHandler: Handler by lazy { Handler(workerThread.looper) }
+    // Lazy, process-lived. Created on first submit, never torn down.
+    private val workerThread: HandlerThread by lazy {
+        HandlerThread("Kaleidoscope.MaskWorker").also { it.start() }
+    }
+    private val workerHandler: Handler by lazy { Handler(workerThread.looper) }
 
-  // Worker-thread-confined state.
-  private var segmenter: ImageSegmenter? = null
-  private var videoTimestamp: Long = 0
+    // Worker-thread-confined state.
+    private var segmenter: ImageSegmenter? = null
+    private var videoTimestamp: Long = 0
 
-  /**
-   * Run segmentation for [inputBmp] off the GL thread. [inputBmp] is the
-   * downsampled, bottom-up GL readback; this uprights it (the selfie model is
-   * trained on upright people and does its worst on an inverted one), segments
-   * it, and hands the raw foreground-confidence mask back via [onMask] in the
-   * SAME upright orientation the caller's EMA/flip-back expects.
-   *
-   * [onMask] is invoked on the worker thread only on success. [onDone] is
-   * invoked on the worker thread exactly once, success or failure, so the
-   * caller can reset its in-flight throttle. [inputBmp] is recycled here.
-   */
-  fun submit(
-    inputBmp: Bitmap,
-    context: Context,
-    onMask: (rawUpright: FloatArray, width: Int, height: Int) -> Unit,
-    onDone: () -> Unit,
-  ) {
-    workerHandler.post {
-      var upright: Bitmap? = null
-      var mpImage: MPImage? = null
-      try {
-        val seg = ensureSegmenter(context)
-        // The GL readback (glReadPixels reads bottom-to-top) is vertically
-        // flipped (head-down). Feed the segmenter an upright copy; the caller
-        // flips the mask back so the upload/composite alignment is untouched.
-        // Vertical flip only, not a 180 rotate (columns are already correct).
-        upright = flipVertical(inputBmp)
-        mpImage = BitmapImageBuilder(upright).build()
-        val result = seg.segmentForVideo(mpImage, videoTimestamp++)
+    /**
+     * Run segmentation for [inputBmp] off the GL thread. [inputBmp] is the
+     * downsampled, bottom-up GL readback; this uprights it (the selfie model is
+     * trained on upright people and does its worst on an inverted one), segments
+     * it, and hands the raw foreground-confidence mask back via [onMask] in the
+     * SAME upright orientation the caller's EMA/flip-back expects.
+     *
+     * [onMask] is invoked on the worker thread only on success. [onDone] is
+     * invoked on the worker thread exactly once, success or failure, so the
+     * caller can reset its in-flight throttle. [inputBmp] is recycled here.
+     */
+    fun submit(
+        inputBmp: Bitmap,
+        context: Context,
+        onMask: (rawUpright: FloatArray, width: Int, height: Int) -> Unit,
+        onDone: () -> Unit,
+    ) {
+        workerHandler.post {
+            var upright: Bitmap? = null
+            var mpImage: MPImage? = null
+            try {
+                val seg = ensureSegmenter(context)
+                // The GL readback (glReadPixels reads bottom-to-top) is vertically
+                // flipped (head-down). Feed the segmenter an upright copy; the caller
+                // flips the mask back so the upload/composite alignment is untouched.
+                // Vertical flip only, not a 180 rotate (columns are already correct).
+                upright = flipVertical(inputBmp)
+                mpImage = BitmapImageBuilder(upright).build()
+                val result = seg.segmentForVideo(mpImage, videoTimestamp++)
 
-        val confidenceMasks = result.confidenceMasks()
-        if (!confidenceMasks.isPresent || confidenceMasks.get().isEmpty()) {
-          Log.w(TAG, "segmentation produced no confidence mask")
-          return@post
+                val confidenceMasks = result.confidenceMasks()
+                if (!confidenceMasks.isPresent || confidenceMasks.get().isEmpty()) {
+                    Log.w(TAG, "segmentation produced no confidence mask")
+                    return@post
+                }
+                // General selfie segmenter: a single foreground-confidence mask
+                // (float [0,1], higher = person). Copy it out of MediaPipe's buffer
+                // into a plain array the caller owns.
+                val maskImage = confidenceMasks.get()[0]
+                val maskW = maskImage.width
+                val maskH = maskImage.height
+                val maskBuffer =
+                    ByteBufferExtractor
+                        .extract(maskImage)
+                        .order(ByteOrder.nativeOrder())
+                        .asFloatBuffer()
+                val raw = FloatArray(maskW * maskH)
+                maskBuffer.rewind()
+                maskBuffer.get(raw)
+                onMask(raw, maskW, maskH)
+            } catch (t: Throwable) {
+                Log.e(TAG, "segmentation failed on worker", t)
+            } finally {
+                // close() in finally: if segmentForVideo throws, the MPImage native
+                // handle would otherwise leak (unbounded if the error recurs per frame).
+                mpImage?.close()
+                upright?.recycle()
+                inputBmp.recycle()
+                onDone()
+            }
         }
-        // General selfie segmenter: a single foreground-confidence mask
-        // (float [0,1], higher = person). Copy it out of MediaPipe's buffer
-        // into a plain array the caller owns.
-        val maskImage = confidenceMasks.get()[0]
-        val maskW = maskImage.width
-        val maskH = maskImage.height
-        val maskBuffer = ByteBufferExtractor.extract(maskImage)
-          .order(ByteOrder.nativeOrder())
-          .asFloatBuffer()
-        val raw = FloatArray(maskW * maskH)
-        maskBuffer.rewind()
-        maskBuffer.get(raw)
-        onMask(raw, maskW, maskH)
-      } catch (t: Throwable) {
-        Log.e(TAG, "segmentation failed on worker", t)
-      } finally {
-        // close() in finally: if segmentForVideo throws, the MPImage native
-        // handle would otherwise leak (unbounded if the error recurs per frame).
-        mpImage?.close()
-        upright?.recycle()
-        inputBmp.recycle()
-        onDone()
-      }
     }
-  }
 
-  private fun ensureSegmenter(context: Context): ImageSegmenter {
-    val existing = segmenter
-    if (existing != null) return existing
-    // Load the model as a direct ByteBuffer (setModelAssetBuffer) rather than
-    // setModelAssetPath: the path variant memory-maps the asset and requires it
-    // to be stored uncompressed (aaptOptions noCompress), which we cannot
-    // guarantee in the CONSUMING app's build. Reading the asset into a direct
-    // buffer ourselves works regardless of apk compression.
-    val appContext = context.applicationContext
-    val modelBytes = appContext.assets.open("selfie_segmenter.tflite").use { it.readBytes() }
-    val modelBuffer = ByteBuffer.allocateDirect(modelBytes.size).order(ByteOrder.nativeOrder())
-    modelBuffer.put(modelBytes)
-    modelBuffer.rewind()
+    private fun ensureSegmenter(context: Context): ImageSegmenter {
+        val existing = segmenter
+        if (existing != null) return existing
+        // Load the model as a direct ByteBuffer (setModelAssetBuffer) rather than
+        // setModelAssetPath: the path variant memory-maps the asset and requires it
+        // to be stored uncompressed (aaptOptions noCompress), which we cannot
+        // guarantee in the CONSUMING app's build. Reading the asset into a direct
+        // buffer ourselves works regardless of apk compression.
+        val appContext = context.applicationContext
+        val modelBytes = appContext.assets.open("selfie_segmenter.tflite").use { it.readBytes() }
+        val modelBuffer = ByteBuffer.allocateDirect(modelBytes.size).order(ByteOrder.nativeOrder())
+        modelBuffer.put(modelBytes)
+        modelBuffer.rewind()
 
-    val baseOptions = BaseOptions.builder()
-      .setModelAssetBuffer(modelBuffer)
-      .build()
-    val options = ImageSegmenter.ImageSegmenterOptions.builder()
-      .setBaseOptions(baseOptions)
-      .setRunningMode(RunningMode.VIDEO)
-      .setOutputConfidenceMasks(true)
-      .setOutputCategoryMask(false)
-      .build()
-    val seg = ImageSegmenter.createFromOptions(appContext, options)
-    segmenter = seg
-    return seg
-  }
+        val baseOptions =
+            BaseOptions
+                .builder()
+                .setModelAssetBuffer(modelBuffer)
+                .build()
+        val options =
+            ImageSegmenter.ImageSegmenterOptions
+                .builder()
+                .setBaseOptions(baseOptions)
+                .setRunningMode(RunningMode.VIDEO)
+                .setOutputConfidenceMasks(true)
+                .setOutputCategoryMask(false)
+                .build()
+        val seg = ImageSegmenter.createFromOptions(appContext, options)
+        segmenter = seg
+        return seg
+    }
 
-  /** Vertical mirror (flip across the horizontal axis). Uprights the
-   * bottom-to-top glReadPixels frame before segmentation. */
-  private fun flipVertical(src: Bitmap): Bitmap {
-    val m = Matrix().apply { postScale(1f, -1f) }
-    return Bitmap.createBitmap(src, 0, 0, src.width, src.height, m, true)
-  }
+    /** Vertical mirror (flip across the horizontal axis). Uprights the
+     * bottom-to-top glReadPixels frame before segmentation. */
+    private fun flipVertical(src: Bitmap): Bitmap {
+        val m = Matrix().apply { postScale(1f, -1f) }
+        return Bitmap.createBitmap(src, 0, 0, src.width, src.height, m, true)
+    }
 }

package/android/src/test/java/com/simiancraft/kaleidoscope/CompositeLayersTest.kt

@@ -0,0 +1,165 @@
+package com.simiancraft.kaleidoscope
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Unit tests for the composite layer-stack wire contract: the JSON that
+ * serializeCompositeLayers (src/index.ts) sends across the bridge and that
+ * CompositeLayers.set/get/clear parses into the snapshot the compositor reads each
+ * frame. These pin the parse rules the iOS CompositeLayers.swift port must match;
+ * the same cases are mirrored in the iOS XCTest suite, so a divergence in either
+ * parser fails on one side.
+ *
+ * Runs as a JVM unit test (testDebugUnitTest): the real org.json is on the test
+ * classpath and android.util.Log is a no-op stub (unitTests.returnDefaultValues).
+ */
+class CompositeLayersTest {
+    // CompositeLayers is a process-global singleton; reset between cases so a prior
+    // set() can't leak into the next assertion.
+    @Before
+    fun reset() = CompositeLayers.clear()
+
+    // The wizard-tower composite exactly as serializeCompositeLayers emits it: a
+    // generative base (clouds, uniforms), the cut-out image (image, source = the
+    // stable image id), then you (direct, subject). The canonical happy path.
+    @Test
+    fun parsesWizardTowerStack() {
+        CompositeLayers.set(
+            """
+            [
+              {"id":"sky","shader":"clouds","target":"background","uniforms":{"uExposure":1.26,"uSkyLowColor":[0.99,0.62,0.03],"uCloudSpeed":0.92}},
+              {"id":"tower","shader":"image","target":"background","source":"wizards-tower"},
+              {"id":"you","shader":"direct","target":"subject"}
+            ]
+            """.trimIndent(),
+        )
+        val layers = CompositeLayers.get()
+        assertEquals(3, layers.size)
+
+        val clouds = layers[0]
+        assertEquals("sky", clouds.id)
+        assertEquals("clouds", clouds.shader)
+        assertEquals("background", clouds.target)
+        assertNull(clouds.blend)
+        assertNull(clouds.source)
+        assertArrayEquals(floatArrayOf(1.26f), clouds.uniforms["uExposure"], EPS)
+        assertArrayEquals(floatArrayOf(0.99f, 0.62f, 0.03f), clouds.uniforms["uSkyLowColor"], EPS)
+
+        val image = layers[1]
+        assertEquals("tower", image.id)
+        assertEquals("image", image.shader)
+        assertEquals("wizards-tower", image.source)
+        assertTrue(image.uniforms.isEmpty())
+
+        val you = layers[2]
+        assertEquals("you", you.id)
+        assertEquals("direct", you.shader)
+        assertEquals("subject", you.target)
+        assertNull(you.source)
+    }
+
+    // An overlay layer carries a blend mode; additive must round-trip, and the
+    // base layer (no blend key) must stay null (the compositor reads null = opaque).
+    @Test
+    fun parsesAdditiveBlendOverOpaqueBase() {
+        CompositeLayers.set(
+            """
+            [
+              {"id":"image","shader":"image","target":"background","source":"stylized-dark"},
+              {"id":"rays","shader":"godrays","target":"background","blend":"additive","uniforms":{"uRayCount":11}}
+            ]
+            """.trimIndent(),
+        )
+        val layers = CompositeLayers.get()
+        assertEquals(2, layers.size)
+        assertEquals("image", layers[0].id)
+        assertNull(layers[0].blend)
+        assertEquals("rays", layers[1].id)
+        assertEquals("additive", layers[1].blend)
+        assertArrayEquals(floatArrayOf(11f), layers[1].uniforms["uRayCount"], EPS)
+    }
+
+    // `id` is always on the wire now; a payload missing it falls back to the array
+    // index so the address stays stable and unique-per-stack rather than colliding.
+    @Test
+    fun fallsBackToIndexWhenIdMissing() {
+        CompositeLayers.set(
+            """[{"shader":"clouds","uniforms":{}},{"shader":"direct","target":"subject"}]""",
+        )
+        val layers = CompositeLayers.get()
+        assertEquals(2, layers.size)
+        assertEquals("0", layers[0].id)
+        assertEquals("1", layers[1].id)
+    }
+
+    // target defaults to "background" when the wire omits it.
+    @Test
+    fun defaultsMissingTargetToBackground() {
+        CompositeLayers.set("""[{"shader":"clouds","uniforms":{}}]""")
+        assertEquals("background", CompositeLayers.get()[0].target)
+    }
+
+    // A scalar uniform normalizes to a one-element array; a numeric array stays a
+    // vector, in order.
+    @Test
+    fun normalizesScalarAndVectorUniforms() {
+        CompositeLayers.set("""[{"shader":"plasma","uniforms":{"speed":0.3,"colorA":[0.0,0.3,0.6]}}]""")
+        val u = CompositeLayers.get()[0].uniforms
+        assertArrayEquals(floatArrayOf(0.3f), u["speed"], EPS)
+        assertArrayEquals(floatArrayOf(0.0f, 0.3f, 0.6f), u["colorA"], EPS)
+    }
+
+    // A uniform whose value is neither a number nor a numeric array is skipped;
+    // the shader keeps its GLSL default for that name. Well-formed siblings stay.
+    @Test
+    fun skipsNonNumericUniformKeepingSiblings() {
+        CompositeLayers.set("""[{"shader":"plasma","uniforms":{"speed":0.3,"bad":"nope"}}]""")
+        val u = CompositeLayers.get()[0].uniforms
+        assertArrayEquals(floatArrayOf(0.3f), u["speed"], EPS)
+        assertNull(u["bad"])
+    }
+
+    // A layer with no shader is skipped; well-formed siblings survive (the parse
+    // is per-layer lenient, not all-or-nothing).
+    @Test
+    fun skipsLayerWithoutShader() {
+        CompositeLayers.set("""[{"target":"background"},{"shader":"direct","target":"subject"}]""")
+        val layers = CompositeLayers.get()
+        assertEquals(1, layers.size)
+        assertEquals("direct", layers[0].shader)
+    }
+
+    @Test
+    fun parsesEmptyStack() {
+        CompositeLayers.set("[]")
+        assertTrue(CompositeLayers.get().isEmpty())
+    }
+
+    // A whole-payload parse failure (not a JSON array) leaves the previous composite
+    // in place rather than blanking the frame.
+    @Test
+    fun keepsPreviousCompositeOnMalformedPayload() {
+        CompositeLayers.set("""[{"shader":"direct","target":"subject"}]""")
+        CompositeLayers.set("not json at all")
+        val layers = CompositeLayers.get()
+        assertEquals(1, layers.size)
+        assertEquals("direct", layers[0].shader)
+    }
+
+    // clear() drops the active composite (a non-composite effect taking over).
+    @Test
+    fun clearEmptiesStack() {
+        CompositeLayers.set("""[{"shader":"direct","target":"subject"}]""")
+        CompositeLayers.clear()
+        assertTrue(CompositeLayers.get().isEmpty())
+    }
+
+    private companion object {
+        const val EPS = 1e-6f
+    }
+}

package/app.plugin.js

@@ -1,255 +1,9 @@
-// Expo config plugin. Native registration happens via the Expo Module's
-// OnCreate hook (see android/.../KaleidoscopeModule.kt and
-// ios/.../KaleidoscopeModule.swift), not through a plugin-time mod.
-//
-// This plugin's job is narrowly scoped: patch the consumer's iOS build to
-// satisfy this library's hard requirements that cannot be expressed in the
-// Expo Module manifest or the podspec alone. Today that means two patches,
-// both installed by a single iOS `dangerous` mod:
-//
-//   1. Declare `pod 'react-native-webrtc', :modular_headers => true` in the
-//      generated Podfile so Swift sources can `import react_native_webrtc`
-//      (see modular-headers detail below).
-//   2. Raise `ios.deploymentTarget` in `Podfile.properties.json` to the value
-//      required by `ios/Kaleidoscope.podspec`. The default Expo Podfile
-//      platform (iOS 13.4) is lower than this library's minimum (iOS 15.0
-//      for Apple Vision person segmentation), and `expo-modules-autolinking`
-//      silently drops pods whose declared minimum exceeds the Podfile
-//      platform — the library would build, install, and then be absent from
-//      the generated `ExpoModulesProvider.swift` at runtime.
-//
-// Bounding invariant for future patches in this mod:
-//   Every patch this mod installs must be (a) idempotent across re-prebuilds,
-//   (b) non-downgrading (never reduce a value the consumer or another plugin
-//   set higher), and (c) recoverable via a logged manual instruction on I/O
-//   failure (no throwing — prebuild must keep going).
-//
-// Ordering note: this mod must run AFTER any consumer plugin that writes the
-// same files (notably `expo-build-properties`). Expo executes plugins in
-// declaration order from `plugins[]`, so consumers must list this plugin
-// AFTER `expo-build-properties` in their `app.config.js`. The demo's
-// `app.config.js` already does so.
-//
-// Modular-headers detail: our Swift sources do `import react_native_webrtc`
-// to reach the Obj-C `ProcessorProvider` class and `VideoFrameProcessorDelegate`
-// protocol that live inside the react-native-webrtc pod. For a Swift target to
-// `import` an Objective-C CocoaPod as a Clang module, that pod must be built with
-// modular headers. react-native-webrtc is NOT built with modular headers by
-// default in a React Native / Expo app, so a default prebuild produces Swift
-// that fails to compile with "no such module 'react_native_webrtc'".
-//
-// We deliberately do NOT emit a global `use_modular_headers!`: that flips every
-// pod to build as a Clang module, which regularly breaks React Native core
-// pods that ship non-modular umbrella headers. A single per-pod opt-in is the
-// narrow, supported fix that react-native-webrtc's own docs recommend.
-//
-// WHY this file requires nothing but Node builtins (no @expo/config-plugins):
-// Expo's plugin resolver hardcodes the entry filename to `app.plugin.js` and
-// loads it with `require()` from the file's REAL path. In the demo we consume
-// this library via `file:..`, so on EAS the realpath is the repo root, where
-// there is no node_modules (EAS only installs the demo subdirectory). A
-// top-level `require('@expo/config-plugins')` therefore throws
-// "Cannot find module '@expo/config-plugins'" on the EAS worker. Registering
-// the dangerous mod by mutating `config.mods.ios.dangerous` directly removes
-// that dependency, so the plugin loads identically from the symlinked demo, a
-// normally-installed external consumer, and the EAS worker. The mod contract is
-// the one @expo/config-plugins' own dangerous base provider calls: it invokes
-// our mod as `nextMod({ ...config, modResults, modRequest })` and only requires
-// the returned value to be the config object (it asserts `.mods` exists).
-//
-// This file is CommonJS, and the package is deliberately `type: commonjs`:
-// Expo's plugin resolver loads app.plugin.js with `require()`, and a CommonJS
-// entry sidesteps ESM-interop variance across the Node versions EAS workers run
-// (older SDK images run Node 18, which cannot `require()` an ESM module at all;
-// newer images run Node 20/22). The ESM-authored library source lives in `src/`
-// and is consumed by Metro via the `react-native` export condition, never
-// loaded by Node.
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-// A sentinel comment lets us find our own injection on re-prebuilds and stay
-// idempotent regardless of how Expo regenerates the surrounding Podfile.
-const SENTINEL = '# react-native-webrtc-kaleidoscope: modular headers (managed)';
-
-// Mirrors ios/Kaleidoscope.podspec :ios => '15.0'. Bumping the podspec
-// requires bumping this constant; the drift cost is a silent pod-install
-// drop (the bug this plan fixes).
-const IOS_DEPLOYMENT_TARGET = '15.0';
-
-// Compare two dotted version strings element-wise. Returns true iff `existing`
-// is strictly less than `target`. Missing/empty existing counts as "less than".
-// We avoid `semver` so this file stays dependency-free for EAS workers that
-// don't install the library's node_modules. The library's iOS deployment
-// target is a plain three-part version like '15.0' (or '15.0.1' if Apple ever
-// requires it); pre-release/build metadata is not part of the contract.
-function isVersionLessThan(existing, target) {
-  if (typeof existing !== 'string' || existing.length === 0) {
-    return true;
-  }
-  const toParts = (s) => s.split('.').map((part) => Number(part) || 0);
-  const a = toParts(existing);
-  const b = toParts(target);
-  const max = Math.max(a.length, b.length);
-  for (let i = 0; i < max; i += 1) {
-    const av = a[i] || 0;
-    const bv = b[i] || 0;
-    if (av < bv) return true;
-    if (av > bv) return false;
-  }
-  return false; // equal
-}
-
-// Resolve which react-native-webrtc fork the consumer installed, and return its
-// CocoaPods pod name + npm package directory (used to build the `:path` for
-// the Podfile declaration). Two forks ship the same JS/native surface under
-// different names (mirrors the dual probe in android/build.gradle):
-//   - @livekit/react-native-webrtc -> pod `livekit-react-native-webrtc`
-//   - react-native-webrtc          -> pod `react-native-webrtc`
-// We prefer the fork when both are present, matching the Swift import order
-// (`#if canImport(livekit_react_native_webrtc)` first). Declaring a pod for a
-// package that is not installed would break `pod install`, so we return null
-// (and skip patching) when neither is found.
-function resolveWebrtcPod(projectRoot) {
-  if (!projectRoot) {
-    return { podName: 'react-native-webrtc', packageDir: 'react-native-webrtc' };
-  }
-  const fork = path.join(projectRoot, 'node_modules', '@livekit', 'react-native-webrtc');
-  const upstream = path.join(projectRoot, 'node_modules', 'react-native-webrtc');
-  if (fs.existsSync(fork)) {
-    return { podName: 'livekit-react-native-webrtc', packageDir: '@livekit/react-native-webrtc' };
-  }
-  if (fs.existsSync(upstream)) {
-    return { podName: 'react-native-webrtc', packageDir: 'react-native-webrtc' };
-  }
-  return null;
-}
-
-// Ensure the Podfile builds the resolved react-native-webrtc pod with modular
-// headers so our Swift can `import` it as a Clang module. Declare with an
-// explicit `:path` (instead of a bare `pod 'name'`) so the build works even
-// when RN autolinking does not register the pod for us — e.g. react-native-webrtc's
-// own `react-native.config.js` only sets `module.exports` under
-// `--use-react-native-macos`, and on EAS workers `use_native_modules!` has been
-// observed to skip the pod entirely as a result. With `:path` provided here,
-// CocoaPods resolves the local podspec directly; when autolinking also picks
-// it up, the two identical-path declarations are merged and modular_headers
-// is applied. Idempotent: running prebuild twice neither duplicates the line
-// nor corrupts the Podfile.
-function patchPodfile(contents, pod) {
-  if (contents.includes(SENTINEL)) {
-    return contents;
-  }
-
-  const block = `${SENTINEL}\n  pod '${pod.podName}', :path => '../node_modules/${pod.packageDir}', :modular_headers => true`;
-  const lines = contents.split('\n');
-
-  // Insert just inside the first `target ... do` block so the per-pod
-  // declaration sits in the same scope as the autolinked React Native pods.
-  const targetIndex = lines.findIndex((line) => /^\s*target\s+['"].*['"]\s+do\b/.test(line));
-  if (targetIndex !== -1) {
-    lines.splice(targetIndex + 1, 0, block);
-    return lines.join('\n');
-  }
-
-  // No `target` block found (unexpected for an Expo-generated Podfile); append
-  // the declaration so the build requirement is at least present.
-  return `${contents.trimEnd()}\n${block}\n`;
-}
-
-const withKaleidoscope = (config) => {
-  if (!config.mods) {
-    config.mods = {};
-  }
-  if (!config.mods.ios) {
-    config.mods.ios = {};
-  }
-
-  // Chain any previously registered iOS dangerous mod so we cooperate with
-  // other plugins instead of clobbering them.
-  const previousMod = config.mods.ios.dangerous;
-
-  config.mods.ios.dangerous = async (modConfig) => {
-    const result = typeof previousMod === 'function' ? await previousMod(modConfig) : modConfig;
-    const modRequest = result.modRequest || {};
-    const platformProjectRoot = modRequest.platformProjectRoot;
-    const pod = resolveWebrtcPod(modRequest.projectRoot);
-    if (platformProjectRoot && pod) {
-      const podfilePath = path.join(platformProjectRoot, 'Podfile');
-      try {
-        const original = fs.readFileSync(podfilePath, 'utf8');
-        const patched = patchPodfile(original, pod);
-        if (patched !== original) {
-          fs.writeFileSync(podfilePath, patched);
-        }
-      } catch (error) {
-        // Non-fatal: surface a clear instruction rather than failing prebuild.
-        const manualLine = `pod '${pod.podName}', :path => '../node_modules/${pod.packageDir}', :modular_headers => true`;
-        console.warn(
-          `[react-native-webrtc-kaleidoscope] Could not patch the Podfile to build ${pod.podName} with modular headers; add "${manualLine}" inside your app target manually. ${String(error)}`,
-        );
-      }
-    }
-    if (platformProjectRoot) {
-      // Raise the consumer's iOS deployment target via Podfile.properties.json.
-      // The generated Podfile reads `podfile_properties['ios.deploymentTarget']`
-      // at the top, so this is the canonical, no-Podfile-edit override seam.
-      // `expo-modules-autolinking`'s package-filter silently drops any pod
-      // whose declared minimum platform exceeds the Podfile platform; without
-      // this bump the Kaleidoscope pod is dropped and the runtime module
-      // lookup throws.
-      const propsPath = path.join(platformProjectRoot, 'Podfile.properties.json');
-      try {
-        let parsed = {};
-        try {
-          const raw = fs.readFileSync(propsPath, 'utf8');
-          try {
-            const candidate = JSON.parse(raw);
-            if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
-              parsed = candidate;
-            }
-          } catch (jsonError) {
-            // Corrupt JSON: warn but proceed with `{}` so the build still gets
-            // the bump it needs. The next prebuild will fully regenerate the
-            // file anyway.
-            console.warn(
-              `[react-native-webrtc-kaleidoscope] Could not parse ${propsPath}; rewriting with defaults. ${String(jsonError)}`,
-            );
-            parsed = {};
-          }
-        } catch (readError) {
-          if (readError && readError.code === 'ENOENT') {
-            parsed = {};
-          } else {
-            // Transient I/O failure (EACCES, EMFILE, ...). Don't clobber the
-            // file when we couldn't actually read it; warn and bail.
-            console.warn(
-              `[react-native-webrtc-kaleidoscope] Could not read ${propsPath}; skipping iOS deployment-target bump. ${String(readError)}`,
-            );
-            return result;
-          }
-        }
-        // Explicit own-key copy into a fresh object to foreclose
-        // `__proto__`-as-literal-key surprises from JSON.parse.
-        const next = {};
-        for (const key of Object.keys(parsed)) {
-          next[key] = parsed[key];
-        }
-        const existing = next['ios.deploymentTarget'];
-        if (isVersionLessThan(existing, IOS_DEPLOYMENT_TARGET)) {
-          next['ios.deploymentTarget'] = IOS_DEPLOYMENT_TARGET;
-        }
-        fs.writeFileSync(propsPath, `${JSON.stringify(next, null, 2)}\n`);
-      } catch (error) {
-        console.warn(
-          `[react-native-webrtc-kaleidoscope] Could not patch ${propsPath} to raise iOS deployment target; add "ios.deploymentTarget": "${IOS_DEPLOYMENT_TARGET}" to Podfile.properties.json under your demo/ios directory manually. ${String(error)}`,
-        );
-      }
-    }
-    return result;
-  };
-
-  return config;
-};
-
-module.exports = withKaleidoscope;
+// Expo config plugin entry. Expo's plugin resolver hardcodes this filename and
+// loads it with require() from the file's REAL path. The implementation is
+// TypeScript under plugin/src, compiled to the COMMITTED plugin/build (see
+// plugin/src/index.ts for why it is committed and dependency-free at load time).
+//
+// Keep this a one-line CommonJS shim: do not add logic here, and do not point it
+// at dist/ (which is gitignored and absent on EAS). Edit plugin/src and run
+// `bun run build:plugin`.
+module.exports = require('./plugin/build');