react-native-image-stitcher 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -16,6 +16,226 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.1] — 2026-05-23
+
+### Fixed
+- **ARCore Image hold time** (PR #15) — `forwardToIncremental` on
+  Android now packs the ARCore `Image` payload synchronously and
+  closes the image immediately, rather than holding it across the JNI
+  hand-off.  Eliminates the "ImageReader: maxImages exceeded" backlog
+  that throttled non-keyframe processing on the A35 at high pan
+  rates.
+
+### Tooling
+- **Example app Metro port pinned to 8082** (cherry-pick from
+  `feature/f8-frame-processor-yuv`).  Mirrored across
+  `example/metro.config.js`, `example/package.json` scripts,
+  `example/ios/RNImageStitcherExample/AppDelegate.swift`, and
+  `example/android/gradle.properties` to keep CLI builds, IDE
+  builds, and Gradle invocations consistent on machines where 8081
+  is already taken.
+
+### Internal
+- Lockfile sync after the v0.4.0 version bump (Podfile.lock spec
+  checksum + npm prune of transitive deps that had drifted from
+  branch experimentation).  No impact on consumers — example-app
+  tooling only.
+
+## [0.4.0] — 2026-05-23
+
+### v0.4 settings revamp (F10)
+
+> [!WARNING]
+> **Breaking type change.**  The flat 45-field `PanoramaSettings`
+> interface from v0.3 has been replaced with three engine-discriminated
+> hierarchical types (`PanoramaSettings`, `SlitscanSettings`,
+> `HybridSettings`).  Consumers passing custom settings literals to
+> `<Camera>` or to a Layer 2 modal must migrate to the new shape; the
+> v0.3 type is deleted, not aliased.  The C++ engine wire format is
+> unchanged — only the JS-side type surface moved.
+>
+> **Migration guide:** [`docs/migrations/v0.3-to-v0.4-panorama-settings.md`](docs/migrations/v0.3-to-v0.4-panorama-settings.md)
+> walks through every recipe (default-only hosts, custom-literal
+> hosts, slit-scan / hybrid hosts, storage migration for persisted
+> settings).
+
+#### Why
+
+The 2026-05-22 audit (entry below in v0.3.0) traced every
+`PanoramaSettings` field's native consumer and proved the flat type
+mixed three engines' (batch-keyframe, slit-scan, hybrid) settings into
+one bag of disjoint subsets.  Hosts had no way to know at the type
+level which settings their chosen engine would even read; the modal
+exposed knobs that were silently ignored on the active engine.  The
+revamp splits the type along engine boundaries so the types match what
+each engine actually consumes.
+
+#### What changed
+
+- **New file:** `src/camera/PanoramaSettings.ts` — `CaptureBaseSettings`
+  + three top-level types (`PanoramaSettings`, `SlitscanSettings`,
+  `HybridSettings`), each with co-located `DEFAULT_*_SETTINGS`.  Sub-trees
+  group related knobs: `stitcher` / `frameSelection.flow` (panorama);
+  `painting` / `registration.ncc1d` / `registration.ncc2d.emaSmoothing` /
+  `registration.ncc2d.panAxisLock` / `plane` / `advanced` (slitscan).
+- **New file:** `src/camera/PanoramaSettingsBridge.ts` — three pure
+  adapter functions (`panoramaSettingsToNativeConfig`,
+  `slitscanSettingsToNativeConfig`, `hybridSettingsToNativeConfig`)
+  that translate the typed JS tree → the flat
+  `Record<string, primitive>` the native bridges consume.  Handles
+  presence-as-enable (`ncc1d` defined ⇒ `enable1dNcc: true` on the
+  wire) and source-conditional plane optionals.
+- **New file:** `src/camera/buildPanoramaInitialSettings.ts` — pure
+  helper that translates `<Camera>`'s `default*` props into the
+  initial `PanoramaSettings` snapshot.  Takes the device's low-mem
+  classification as an argument so the function stays pure and
+  testable.
+- **Rewritten:** `src/camera/PanoramaSettingsModal.tsx` — now consumes
+  the new `PanoramaSettings` shape.  UI sections mirror the type tree
+  (Capture source, Debug, Stitcher accordion, Frame Selection
+  accordion with nested Flow tunables).  ~600 LOC smaller than v0.3
+  because dead slit-scan / hybrid / video-recording fields are gone.
+- **Rewired:** `src/camera/Camera.tsx` — settings state uses the new
+  type; `incremental.start({ config })` now passes
+  `panoramaSettingsToNativeConfig(settings)` instead of an inline flat
+  dict.  IMU translation gate reads
+  `settings.frameSelection.flow?.maxTranslationCm`.  Debug overlay
+  reads `settings.frameSelection.mode` + `settings.stitcher.stitchMode`.
+- **Updated:** `src/index.ts` — exports the new types + adapters; drops
+  the deleted v0.3 type.
+- **Test infra:** added `jest` + `ts-jest` + `@types/jest` devDeps; new
+  `jest.config.js`, `tsconfig.test.json`, `tsconfig.build.json` (the
+  latter excludes `__tests__/` from the shipped `dist/`).  19 tests
+  across two suites cover the bridge round-trips, presence-as-enable
+  cases, plane-source variants, and prop→settings-tree translation.
+
+#### Migration table — v0.3 flat → v0.4 hierarchical
+
+For `<Camera>`-consuming hosts (the only public path that took
+`PanoramaSettings` in v0.3):
+
+| v0.3 field                       | v0.4 path                                       |
+|----------------------------------|-------------------------------------------------|
+| `captureSource`                  | `captureSource` (unchanged)                     |
+| `debug`                          | `debug` (unchanged)                             |
+| `stitchMode`                     | `stitcher.stitchMode`                           |
+| `warperType`                     | `stitcher.warperType`                           |
+| `blenderType`                    | `stitcher.blenderType`                          |
+| `seamFinderType`                 | `stitcher.seamFinderType`                       |
+| `enableMaxInscribedRectCrop`     | `stitcher.enableMaxInscribedRectCrop`           |
+| `frameSelectionMode`             | `frameSelection.mode`                           |
+| `keyframeMaxCount`               | `frameSelection.maxKeyframes`                   |
+| `keyframeOverlapThreshold`       | `frameSelection.overlapThreshold`               |
+| `flowNoveltyPercentile`          | `frameSelection.flow.noveltyPercentile`         |
+| `flowEvalEveryNFrames`           | `frameSelection.flow.evalEveryNFrames`          |
+| `flowMaxTranslationCm`           | `frameSelection.flow.maxTranslationCm`          |
+| `flowMaxCorners`                 | `frameSelection.flow.maxCorners`                |
+| `flowQualityLevel`               | `frameSelection.flow.qualityLevel`              |
+| `flowMinDistance`                | `frameSelection.flow.minDistance`               |
+
+#### Deleted from the public type surface
+
+These fields were consumed only by slit-scan or hybrid engines (or
+not consumed at all per the audit) and were dead surface on
+`<Camera>`'s batch-keyframe path:
+
+- `incrementalEngine` — `<Camera>` always uses `batch-keyframe`; the
+  knob never reached this component.  Hosts that want slit-scan or
+  hybrid build their own capture flow on `incremental.start()` and
+  pass `SlitscanSettings` / `HybridSettings` instead.
+- `useARPreview` — superseded by `captureSource` ('ar' / 'non-ar').
+- `useDetectedPlane` — superseded by `SlitscanSettings.plane.source`.
+- `planeSource`, `virtualPlaneDepthMeters`, `arkitPlaneAlignmentThreshold`,
+  `planeProjectionStyle` — slit-scan only; on `SlitscanSettings.plane.*`.
+- `slitWidthFraction`, `sliverPosition`, `firstFrameFullFrame`,
+  `paintMode` — slit-scan only; on `SlitscanSettings.painting.*`.
+- `acceptGate`, `enableTriangulation`, `enableTriAccumulator`,
+  `enable2dNcc`, `enableRansacHomography`, `nccSearchRadius1d`,
+  `nccSearchMargin2d`, `nccConfidenceThreshold2d`,
+  `enableNcc2dEmaSmoothing`, `ncc2dEmaAlpha`,
+  `enableNcc2dPanAxisLock`, `ncc2dCrossAxisLockPx` — slit-scan only;
+  on `SlitscanSettings.registration.*`.
+- `hybridProjection` — hybrid only; on `HybridSettings.projection`.
+- `maxRecordingMs`, `framesPerSecond`, `minFrames`, `maxFrames`,
+  `quality` — historical video-recording fallback fields with no
+  consumer on `<Camera>`'s batch-keyframe path.
+
+#### Latent v0.3 bug fixed in passing
+
+The v0.3 `<Camera>` accepted a `defaultCaptureSource` prop but the
+internal `buildInitialSettings` function never copied it into
+`settings.captureSource` — only into `arPreference` state.  The
+discrepancy meant the wire dict sent to native always reported
+`captureSource: 'ar'` even when the operator's effective source was
+`'non-ar'`, which silently disabled Android's `disableAngularFallback`
+opt-out (audit fix F1).  v0.4's `extractPanoramaOverrides` +
+`buildPanoramaInitialSettings` route the prop through correctly.
+Hosts using `defaultCaptureSource="non-ar"` will see native receive
+the matching value for the first time.
+
+#### Known limitation — modal Capture-source field vs. AR toggle
+
+The on-screen AR toggle button at the bottom of `<Camera>` updates
+`arPreference` state (and through it `effectiveCaptureSource`),
+which decides which preview component mounts.  The Capture-source
+segmented control inside the settings modal updates
+`settings.captureSource`, which only affects what's reported to the
+native engine via `panoramaSettingsToNativeConfig` (gates Android's
+angular-fallback opt-out per audit fix F1).  These two values can
+drift if the operator toggles the AR button without re-opening
+settings, OR flips the modal field without touching the AR button.
+The on-screen toggle is the canonical UI affordance for the live
+preview path; the modal field is best thought of as a tester escape
+hatch for the wire-format consequence.  A future cleanup is to make
+both update the same source of truth — out of scope for v0.4.
+
+#### Migration example
+
+```ts
+// Before (v0.3)
+const settings: PanoramaSettings = {
+  captureSource: 'ar',
+  stitchMode: 'auto',
+  blenderType: 'multiband',
+  flowMaxTranslationCm: 50,
+  flowNoveltyPercentile: 0.85,
+  keyframeMaxCount: 6,
+  frameSelectionMode: 'flow-based',
+  // … 40+ more fields
+};
+
+// After (v0.4)
+const settings: PanoramaSettings = {
+  captureSource: 'ar',
+  debug: false,
+  stitcher: {
+    stitchMode: 'auto',
+    warperType: 'plane',
+    blenderType: 'multiband',
+    seamFinderType: 'graphcut',
+    enableMaxInscribedRectCrop: false,
+  },
+  frameSelection: {
+    mode: 'flow-based',
+    maxKeyframes: 6,
+    overlapThreshold: 0.20,
+    flow: {
+      noveltyPercentile: 0.85,
+      evalEveryNFrames: 5,
+      maxTranslationCm: 50,
+      maxCorners: 150,
+      qualityLevel: 0.01,
+      minDistance: 10,
+    },
+  },
+};
+
+// Or just use the default:
+import { DEFAULT_PANORAMA_SETTINGS } from 'react-native-image-stitcher';
+const settings = { ...DEFAULT_PANORAMA_SETTINGS, captureSource: 'non-ar' };
+```
+
+
 ## [0.3.0] — 2026-05-23
 
 > [!IMPORTANT]

package/android/src/main/java/io/imagestitcher/rn/RNSARCameraView.kt

@@ -428,133 +428,146 @@ class RNSARCameraView @JvmOverloads constructor(
             }
             return
         }
-        try {
-            // 2026-05-21 (v0.3) — pixel-data path.  Pre-0.3 this code
-            // unconditionally encoded the YUV camera image to JPEG and
-            // wrote it to disk for EVERY ARCore frame at ~60 Hz (~25 ms
-            // per frame of JPEG encode + disk I/O on the GL render
-            // thread), regardless of whether the C++ KeyframeGate would
-            // accept it.  Now we extract the Y plane bytes (cheap
-            // memcpy from a DirectByteBuffer), feed them to the gate
-            // for proper Flow-strategy evaluation, and defer the JPEG
-            // encode + disk write to the `onAccept` lambda so it only
-            // runs on the rare frames the gate actually keeps
-            // (typically ~6 per capture).
-            //
-            // Y-plane extraction for ARCore's YUV_420_888 format:
-            // plane[0] is the luminance channel at full resolution,
-            // pixelStride=1, rowStride may equal width OR be padded.
-            // We pass rowStride as the C++ side's `stride` so the gate
-            // skips padding correctly.
-            val yPlane = image.planes[0]
-            val yBuffer = yPlane.buffer
-            val yStride = yPlane.rowStride
-            val yWidth = image.width
-            val yHeight = image.height
-            // Copy Y bytes into a JVM-side ByteArray.  Using
-            // duplicate() so we don't mutate the original buffer's
-            // position state (ARCore may have other readers).
-            // For 1920×1080 Y plane that's ~2 MB; on Galaxy A35 the
-            // memcpy itself is < 1 ms.  JNI side pins via
-            // GetPrimitiveArrayCritical so the byte[] stays a single
-            // copy through the entire frame's lifecycle.
-            val ySize = yStride * yHeight
-            val yBytes = ByteArray(ySize)
-            yBuffer.duplicate().apply { rewind() }.get(yBytes, 0, ySize)
-
-            // Compute yaw + pitch from the ARCore quaternion using
-            // the same convention the iOS Swift side uses (camera-
-            // forward in world space).  This keeps the two platforms
-            // numerically aligned for the FoV-overlap gate.
-            val q = camera.pose.rotationQuaternion  // x, y, z, w
-            val (yaw, pitch) = quaternionYawPitch(q)
-
-            // Both FoVs + the full quaternion + intrinsics go to the
-            // engine.  V6 pose-driven path uses (qx, qy, qz, qw, fx,
-            // fy, cx, cy, w, h) to compute the geometrically-exact
-            // homography.
-            val intrinsics = camera.imageIntrinsics
-            val fx = intrinsics.focalLength[0].toDouble()
-            val fy = intrinsics.focalLength[1].toDouble()
-            val cxIntr = intrinsics.principalPoint[0].toDouble()
-            val cyIntr = intrinsics.principalPoint[1].toDouble()
-            val w = intrinsics.imageDimensions[0].toDouble()
-            val h = intrinsics.imageDimensions[1].toDouble()
-            val fovHRad = 2.0 * atan(w / (2.0 * fx))
-            val fovVRad = 2.0 * atan(h / (2.0 * fy))
-            val fovHDeg = fovHRad * 180.0 / Math.PI
-            val fovVDeg = fovVRad * 180.0 / Math.PI
-
-            // ARCore quaternion comes back in (x, y, z, w) order.
-            val qarr = camera.pose.rotationQuaternion
-            // P3-F: also extract translation so the KeyframeGate's
-            // plane-based ray-projection can compute polygon overlap.
-            // Previously these were dropped, forcing the gate into
-            // angular-fallback even when a plane was latched.
-            val tArr = camera.pose.translation
-
-            val trackingPoor = camera.trackingState != TrackingState.TRACKING
-            val module = IncrementalStitcher.bridgeInstance ?: return
-            // 2026-05-15 (B3) — pass current display rotation so the
-            // encoded JPEG gets an EXIF orientation tag.  Captured into
-            // a local val so the lambda below closes over a primitive
-            // (avoids re-reading lastDisplayRotation if it shifts
-            // between gate-evaluate and lambda invocation).
-            val rotationForEncode = if (lastDisplayRotation >= 0)
-                lastDisplayRotation else android.view.Surface.ROTATION_0
-            // 2026-05-21 (v0.3) — eager JPEG encode is only needed when
-            // the engine is in the legacy hybrid/firstwins live-engine
-            // mode (which feeds JPEG paths into addFrameAtPath every
-            // frame).  In batch-keyframe mode (the production Camera
-            // component's path), the JPEG is encoded LAZILY inside
-            // the onAccept lambda below — only on the ~6 frames per
-            // capture that the C++ KeyframeGate actually keeps.
-            val legacyJpegPath: String? = if (module.isBatchKeyframeMode) {
-                null
-            } else {
-                YuvImageConverter.encodeToJpeg(
-                    image,
-                    tmpJpegFile.absolutePath,
-                    jpegQuality = 70,
-                    displayRotation = rotationForEncode,
-                )
+
+        // 2026-05-22 (audit follow-up #19) — minimise ARCore Image
+        // hold time.
+        //
+        // Pre-#19 the Image stayed open through the entire JNI
+        // ingest call AND any subsequent JPEG encode (~25 ms in
+        // legacy hybrid mode where every frame is encoded eagerly;
+        // ~25 ms in batch-keyframe mode for the ~5/60 frames the
+        // gate accepts).  At 60 Hz ARCore that meant the Image was
+        // held 25-30 ms per frame on accepts, starving the Camera2
+        // ImageReader's circular buffer pool and risking
+        // "BufferQueue has been abandoned" stalls.
+        //
+        // The fix is mechanical: pack the YUV planes into a
+        // JVM-side NV21 byte array (~3 ms), close the Image, and
+        // run all subsequent work (JNI ingest + JPEG encode) on
+        // the copied bytes.  ARCore Camera2 buffer pool stays
+        // healthier; latency-sensitive ARCore frames flow through
+        // their fixed pool instead of waiting on our JPEG path.
+        //
+        // The packed.nv21 array's first `width*height` bytes are
+        // the Y plane (densely packed, stride = width) — these go
+        // to the C++ gate as grayscale.  The full array is the
+        // input to YuvImageConverter.encodeJpegFromNV21 if the
+        // gate accepts (or if we're in legacy eager-encode mode).
+        val packed = try {
+            YuvImageConverter.packNV21(image)
+        } finally {
+            // Close ASAP — every microsecond reduces buffer-pool
+            // pressure on Camera2.  Even if packNV21 returns null
+            // (unsupported format), we still need to close.
+            try { image.close() } catch (_: Throwable) {}
+        } ?: run {
+            if (forwardLogTick % 30 == 1) {
+                Log.w(TAG, "forwardToIncremental: packNV21 returned null (unexpected format?)")
             }
-            module.ingestFromARCameraView(
-                tx = tArr[0].toDouble(),
-                ty = tArr[1].toDouble(),
-                tz = tArr[2].toDouble(),
-                qx = qarr[0].toDouble(), qy = qarr[1].toDouble(),
-                qz = qarr[2].toDouble(), qw = qarr[3].toDouble(),
-                fx = fx, fy = fy, cx = cxIntr, cy = cyIntr,
-                imageWidth = intrinsics.imageDimensions[0],
-                imageHeight = intrinsics.imageDimensions[1],
-                yaw = yaw, pitch = pitch,
-                fovHorizDegrees = fovHDeg, fovVertDegrees = fovVDeg,
-                trackingPoor = trackingPoor,
-                grayData = yBytes,
-                grayWidth = yWidth,
-                grayHeight = yHeight,
-                grayStride = yStride,
-                legacyJpegPath = legacyJpegPath,
-                onAccept = { targetPath ->
-                    // Lazy JPEG encode.  Runs ONLY if the C++ KeyframeGate
-                    // accepted the frame.  The ARCore Image is still open
-                    // at this point (we haven't reached `image.close()`
-                    // in the surrounding `finally` block yet), so the
-                    // encode reads raw camera pixels directly into a
-                    // JPEG at the final persistent path — no tmp file,
-                    // no second copy.
-                    YuvImageConverter.encodeToJpeg(
-                        image,
-                        targetPath,
-                        jpegQuality = 70,
-                        displayRotation = rotationForEncode,
-                    ) != null
-                },
+            return
+        }
+
+        // Compute yaw + pitch from the ARCore quaternion using
+        // the same convention the iOS Swift side uses (camera-
+        // forward in world space).  This keeps the two platforms
+        // numerically aligned for the FoV-overlap gate.  `camera`
+        // (and `camera.pose`) remain valid after image.close() —
+        // they're ARCore Frame metadata, not pixel buffers.
+        val q = camera.pose.rotationQuaternion  // x, y, z, w
+        val (yaw, pitch) = quaternionYawPitch(q)
+
+        // Both FoVs + the full quaternion + intrinsics go to the
+        // engine.  V6 pose-driven path uses (qx, qy, qz, qw, fx,
+        // fy, cx, cy, w, h) to compute the geometrically-exact
+        // homography.
+        val intrinsics = camera.imageIntrinsics
+        val fx = intrinsics.focalLength[0].toDouble()
+        val fy = intrinsics.focalLength[1].toDouble()
+        val cxIntr = intrinsics.principalPoint[0].toDouble()
+        val cyIntr = intrinsics.principalPoint[1].toDouble()
+        val w = intrinsics.imageDimensions[0].toDouble()
+        val h = intrinsics.imageDimensions[1].toDouble()
+        val fovHRad = 2.0 * atan(w / (2.0 * fx))
+        val fovVRad = 2.0 * atan(h / (2.0 * fy))
+        val fovHDeg = fovHRad * 180.0 / Math.PI
+        val fovVDeg = fovVRad * 180.0 / Math.PI
+
+        // ARCore quaternion comes back in (x, y, z, w) order.
+        val qarr = camera.pose.rotationQuaternion
+        // P3-F: also extract translation so the KeyframeGate's
+        // plane-based ray-projection can compute polygon overlap.
+        // Previously these were dropped, forcing the gate into
+        // angular-fallback even when a plane was latched.
+        val tArr = camera.pose.translation
+
+        val trackingPoor = camera.trackingState != TrackingState.TRACKING
+        val module = IncrementalStitcher.bridgeInstance ?: return
+        // 2026-05-15 (B3) — pass current display rotation so the
+        // encoded JPEG gets an EXIF orientation tag.  Captured into
+        // a local val so the lambda below closes over a primitive
+        // (avoids re-reading lastDisplayRotation if it shifts
+        // between gate-evaluate and lambda invocation).
+        val rotationForEncode = if (lastDisplayRotation >= 0)
+            lastDisplayRotation else android.view.Surface.ROTATION_0
+
+        // 2026-05-21 (v0.3) — eager JPEG encode is only needed when
+        // the engine is in the legacy hybrid/firstwins live-engine
+        // mode (which feeds JPEG paths into addFrameAtPath every
+        // frame).  In batch-keyframe mode (the production Camera
+        // component's path), the JPEG is encoded LAZILY inside
+        // the onAccept lambda below — only on the ~6 frames per
+        // capture that the C++ KeyframeGate actually keeps.
+        //
+        // 2026-05-22 (#19) — the encode now reads from the already-
+        // packed NV21 bytes (`packed`), NOT from the live Image
+        // (which has been closed above).  Same output, no Image
+        // hold time.
+        val legacyJpegPath: String? = if (module.isBatchKeyframeMode) {
+            null
+        } else {
+            YuvImageConverter.encodeJpegFromNV21(
+                packed,
+                tmpJpegFile.absolutePath,
+                jpegQuality = 70,
+                displayRotation = rotationForEncode,
             )
-        } finally {
-            image.close()
         }
+        module.ingestFromARCameraView(
+            tx = tArr[0].toDouble(),
+            ty = tArr[1].toDouble(),
+            tz = tArr[2].toDouble(),
+            qx = qarr[0].toDouble(), qy = qarr[1].toDouble(),
+            qz = qarr[2].toDouble(), qw = qarr[3].toDouble(),
+            fx = fx, fy = fy, cx = cxIntr, cy = cyIntr,
+            imageWidth = intrinsics.imageDimensions[0],
+            imageHeight = intrinsics.imageDimensions[1],
+            yaw = yaw, pitch = pitch,
+            fovHorizDegrees = fovHDeg, fovVertDegrees = fovVDeg,
+            trackingPoor = trackingPoor,
+            // The Y plane lives at packed.nv21[0 .. width*height).
+            // C++ keyframe_gate reads `height * stride` bytes and
+            // ignores anything past that, so passing the full NV21
+            // array with `grayStride = width` reads exactly the Y
+            // plane (UV bytes at the tail are not touched).
+            grayData = packed.nv21,
+            grayWidth = packed.width,
+            grayHeight = packed.height,
+            grayStride = packed.width,
+            legacyJpegPath = legacyJpegPath,
+            onAccept = { targetPath ->
+                // Lazy JPEG encode.  Runs ONLY if the C++ KeyframeGate
+                // accepted the frame.  Encodes from the pre-packed
+                // NV21 bytes — the ARCore Image has been closed since
+                // ~25 ms ago (right after packNV21), so no
+                // Image-hold cost on this slow path.
+                YuvImageConverter.encodeJpegFromNV21(
+                    packed,
+                    targetPath,
+                    jpegQuality = 70,
+                    displayRotation = rotationForEncode,
+                ) != null
+            },
+        )
     }
 
     private fun applyDisplayGeometry() {