react-native-image-stitcher 0.15.2 → 0.16.0

package/cpp/tests/pose_test.cpp

@@ -1,74 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// pose_test.cpp — v0.10.0 audit #9A
-//
-// Layout / size invariants for the cross-platform POD structs that
-// marshal AR-frame pose data between Swift/Kotlin and shared C++.
-// The Pose / PlaneTransform structs MUST stay binary-compatible
-// across iOS (Swift → C++) and Android (Kotlin → JNI → C++) — any
-// silent field reorder, padding shift, or size change would diverge
-// gate decisions between platforms.
-//
-// These are pinned to the contract in `cpp/ar_frame_pose.h`'s
-// docstring; if the struct shape evolves intentionally, update both
-// the docstring and these tests in the same commit.
-
-#include "ar_frame_pose.h"
-
-#include <gtest/gtest.h>
-
-#include <cstddef>
-#include <type_traits>
-
-using retailens::Pose;
-using retailens::PlaneTransform;
-
-TEST(PoseLayoutTest, IsStandardLayoutPod) {
-  // Required for `memcpy` marshalling and for the iOS Obj-C++ /
-  // Android JNI bridges to write into the struct directly.
-  EXPECT_TRUE(std::is_standard_layout<Pose>::value);
-  EXPECT_TRUE(std::is_trivially_copyable<Pose>::value);
-}
-
-TEST(PoseLayoutTest, SizeMatchesExpectedFields) {
-  // 11 floats (tx, ty, tz, qx, qy, qz, qw, fx, fy, cx, cy) + 2 int32_t
-  // (imageWidth, imageHeight) = 11*4 + 2*4 = 52 bytes.  No padding
-  // expected: every field is 4-byte aligned and the struct contains
-  // only 4-byte primitives.
-  EXPECT_EQ(sizeof(Pose), static_cast<std::size_t>(11 * 4 + 2 * 4));
-}
-
-TEST(PoseLayoutTest, FieldOrderMatchesContract) {
-  // Translation comes before rotation; rotation before intrinsics;
-  // intrinsics before image dimensions.  Swift / Kotlin marshallers
-  // assume this order — flipping any pair silently breaks the
-  // memcpy-based bridge.
-  EXPECT_EQ(offsetof(Pose, tx), 0u);
-  EXPECT_EQ(offsetof(Pose, ty), sizeof(float) * 1);
-  EXPECT_EQ(offsetof(Pose, tz), sizeof(float) * 2);
-  EXPECT_EQ(offsetof(Pose, qx), sizeof(float) * 3);
-  EXPECT_EQ(offsetof(Pose, qy), sizeof(float) * 4);
-  EXPECT_EQ(offsetof(Pose, qz), sizeof(float) * 5);
-  EXPECT_EQ(offsetof(Pose, qw), sizeof(float) * 6);
-  EXPECT_EQ(offsetof(Pose, fx), sizeof(float) * 7);
-  EXPECT_EQ(offsetof(Pose, fy), sizeof(float) * 8);
-  EXPECT_EQ(offsetof(Pose, cx), sizeof(float) * 9);
-  EXPECT_EQ(offsetof(Pose, cy), sizeof(float) * 10);
-  EXPECT_EQ(offsetof(Pose, imageWidth), sizeof(float) * 11);
-  EXPECT_EQ(offsetof(Pose, imageHeight),
-            sizeof(float) * 11 + sizeof(int32_t));
-}
-
-TEST(PlaneTransformLayoutTest, IsStandardLayoutPod) {
-  EXPECT_TRUE(std::is_standard_layout<PlaneTransform>::value);
-  EXPECT_TRUE(std::is_trivially_copyable<PlaneTransform>::value);
-}
-
-TEST(PlaneTransformLayoutTest, SixteenFloatsContiguous) {
-  // The `m[16]` array MUST be a contiguous 64-byte block — both
-  // bridges call `memcpy(planeTransform.m, source, 64)`.  No leading
-  // padding, no field reorder (there's only one field, but pinning the
-  // size catches any accidental wrapper/struct change).
-  EXPECT_EQ(sizeof(PlaneTransform), static_cast<std::size_t>(16 * 4));
-  EXPECT_EQ(offsetof(PlaneTransform, m), 0u);
-}

package/cpp/tests/stitcher_frame_data_test.cpp

@@ -1,132 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// stitcher_frame_data_test.cpp — v0.10.0 audit #9A
-//
-// Sanity coverage for the `StitcherFrameData` POD payload + the
-// `PixelBufferReader` interface contract.  The shared C++
-// `StitcherFrameData` is constructed by both the iOS Obj-C++ side
-// (`StitcherFrameHostObject.mm`) and the Android JNI side
-// (`stitcher_frame_jni.cpp`); these tests pin the default-construction
-// invariants both sides depend on (e.g. `hasTranslation=false`,
-// `qw=1.0`).
-//
-// The `PixelBufferReader` tests use a fake-buffer implementation
-// (`FakePixelBufferReader`) to validate the `copyTo` clipping
-// behaviour the docstring promises.
-
-#include "stitcher_frame_data.hpp"
-
-#include <gtest/gtest.h>
-
-#include <cstdint>
-#include <cstring>
-#include <memory>
-#include <vector>
-
-using retailens::PixelBufferReader;
-using retailens::StitcherFrameData;
-
-namespace {
-
-/// Minimal fake reader — backs a fixed byte vector.  Used by the
-/// `PixelBufferReader` contract tests below to verify
-/// `copyTo` clips at the smaller of (maxBytes, byteSize).
-class FakePixelBufferReader : public PixelBufferReader {
- public:
-  explicit FakePixelBufferReader(std::vector<uint8_t> bytes)
-      : _bytes(std::move(bytes)) {}
-
-  std::size_t byteSize() const override { return _bytes.size(); }
-
-  std::size_t copyTo(uint8_t* dst, std::size_t maxBytes) override {
-    const std::size_t n =
-        maxBytes < _bytes.size() ? maxBytes : _bytes.size();
-    std::memcpy(dst, _bytes.data(), n);
-    return n;
-  }
-
- private:
-  std::vector<uint8_t> _bytes;
-};
-
-}  // namespace
-
-// ─── StitcherFrameData default-construction invariants ─────────────
-
-TEST(StitcherFrameDataTest, DefaultsAreSafeForJSIDispatch) {
-  // The JSI host object's `get()` dispatch keys off these defaults to
-  // expose `undefined` for unset fields.  In particular:
-  //   - `hasTranslation == false`  →  pose.translation === undefined
-  //   - `arTrackingState.empty()`  →  arTrackingState === undefined
-  //   - `qw == 1.0` with rest zero →  identity rotation (safe default
-  //     for non-AR mode where rotation is unknown)
-  StitcherFrameData d;
-  EXPECT_EQ(d.width, 0);
-  EXPECT_EQ(d.height, 0);
-  EXPECT_TRUE(d.source.empty());
-  EXPECT_TRUE(d.pixelFormat.empty());
-  EXPECT_TRUE(d.orientation.empty());
-  EXPECT_DOUBLE_EQ(d.timestampNs, 0.0);
-  EXPECT_DOUBLE_EQ(d.qx, 0.0);
-  EXPECT_DOUBLE_EQ(d.qy, 0.0);
-  EXPECT_DOUBLE_EQ(d.qz, 0.0);
-  EXPECT_DOUBLE_EQ(d.qw, 1.0);  // identity rotation
-  EXPECT_DOUBLE_EQ(d.tx, 0.0);
-  EXPECT_DOUBLE_EQ(d.ty, 0.0);
-  EXPECT_DOUBLE_EQ(d.tz, 0.0);
-  EXPECT_FALSE(d.hasTranslation);
-  EXPECT_TRUE(d.arTrackingState.empty());
-  EXPECT_EQ(d.pixelReader, nullptr);
-}
-
-TEST(StitcherFrameDataTest, IsCopyable) {
-  // `StitcherFrameData` is documented as "value-typed (cheap to copy;
-  // ~100 bytes)".  Copy needs to deep-copy the strings + bump the
-  // pixelReader shared_ptr refcount.
-  StitcherFrameData a;
-  a.source = "ar";
-  a.width = 1920;
-  a.height = 1080;
-  a.pixelReader = std::make_shared<FakePixelBufferReader>(
-      std::vector<uint8_t>{1, 2, 3});
-
-  StitcherFrameData b = a;
-  EXPECT_EQ(b.source, "ar");
-  EXPECT_EQ(b.width, 1920);
-  EXPECT_EQ(b.height, 1080);
-  ASSERT_NE(b.pixelReader, nullptr);
-  EXPECT_EQ(b.pixelReader.use_count(), 2);  // both a and b hold a ref
-  EXPECT_EQ(b.pixelReader->byteSize(), 3u);
-}
-
-// ─── PixelBufferReader contract ────────────────────────────────────
-
-TEST(PixelBufferReaderTest, CopyToReturnsAllBytesWhenMaxBytesExceedsSize) {
-  FakePixelBufferReader reader({0x11, 0x22, 0x33});
-  uint8_t buf[8] = {0};
-  const std::size_t written = reader.copyTo(buf, sizeof(buf));
-  EXPECT_EQ(written, 3u);
-  EXPECT_EQ(buf[0], 0x11);
-  EXPECT_EQ(buf[1], 0x22);
-  EXPECT_EQ(buf[2], 0x33);
-  EXPECT_EQ(buf[3], 0u);  // untouched tail
-}
-
-TEST(PixelBufferReaderTest, CopyToClipsWhenMaxBytesIsSmaller) {
-  // Contract per stitcher_frame_data.hpp: "Implementations MUST handle
-  // the case where maxBytes < byteSize() (clip silently)."
-  FakePixelBufferReader reader({0xAA, 0xBB, 0xCC, 0xDD});
-  uint8_t buf[2] = {0};
-  const std::size_t written = reader.copyTo(buf, sizeof(buf));
-  EXPECT_EQ(written, 2u);
-  EXPECT_EQ(buf[0], 0xAA);
-  EXPECT_EQ(buf[1], 0xBB);
-}
-
-TEST(PixelBufferReaderTest, CopyToWithZeroMaxBytesReturnsZero) {
-  FakePixelBufferReader reader({0x01, 0x02, 0x03});
-  uint8_t dummy = 0xFF;
-  const std::size_t written = reader.copyTo(&dummy, 0);
-  EXPECT_EQ(written, 0u);
-  EXPECT_EQ(dummy, 0xFF);  // dst untouched when maxBytes == 0
-}

package/cpp/tests/stubs/jsi/jsi.h

@@ -1,33 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// jsi.h — TEST-ONLY stub of facebook::jsi types.
-//
-// The real jsi.h ships with React Native and pulls in a large surface
-// area (Runtime, Value, Object, Function, HostObject, HostFunction,
-// Array, ArrayBuffer, PropNameID, …) along with the build infra to
-// link them.  For pure-C++ unit tests that exercise data-structure
-// invariants of code that REFERENCES jsi types but never CALLS into
-// them (e.g. `StitcherWorkletRegistry` storing a `shared_ptr` and
-// forwarding `Runtime&` to a constructor stub), we only need the
-// types to be NAMED so headers compile.
-//
-// Pattern: this stub is placed first on the test target's include
-// path so `#include <jsi/jsi.h>` resolves here instead of to RN's
-// real header.  Production builds NEVER see this file — it lives
-// only under `cpp/tests/stubs/`, which is referenced exclusively by
-// `cpp/tests/CMakeLists.txt`.
-//
-// Tests that need to actually CONSTRUCT or CALL into JSI types should
-// not use this stub — they should run against a real JSI runtime (a
-// future v0.11.0+ test target that links Hermes).
-
-#pragma once
-
-namespace facebook {
-namespace jsi {
-
-class Runtime {};
-class Value {};
-
-}  // namespace jsi
-}  // namespace facebook

package/cpp/tests/stubs/react-native-worklets-core/WKTJsiWorklet.h

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-//
-// WKTJsiWorklet.h — TEST-ONLY stub of RNWorklet::WorkletInvoker.
-//
-// `cpp/stitcher_worklet_registry.cpp` constructs a
-// `std::make_shared<RNWorklet::WorkletInvoker>(runtime, value)` inside
-// `install`.  The real WorkletInvoker (from react-native-worklets-core)
-// captures the worklet's source / closure / runtime affinity and is
-// non-trivial to stand up in a unit-test context.
-//
-// This stub provides JUST the symbols needed for the registry to
-// compile and link.  The constructor and destructor are no-ops; calling
-// methods on a stub invoker is undefined behaviour, but the registry
-// itself never does (it only stores the shared_ptr and hands it out
-// via `snapshot`).  Tests construct entries directly via
-// `_installEntryForTests(nullptr)` to avoid even the trivial
-// allocation.
-//
-// See cpp/tests/stubs/jsi/jsi.h for the parallel stub of facebook::jsi.
-
-#pragma once
-
-#include <jsi/jsi.h>
-
-namespace RNWorklet {
-
-class WorkletInvoker {
- public:
-  WorkletInvoker(facebook::jsi::Runtime& /*runtime*/,
-                 const facebook::jsi::Value& /*workletValue*/) {}
-  ~WorkletInvoker() = default;
-};
-
-}  // namespace RNWorklet

package/cpp/tests/warp_guard_test.cpp

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for the warp-canvas size guard (cpp/warp_guard.hpp).
- *
- * The guard decides when a warp ROI is "degenerate" — the trigger for
- * both the cylindrical-fallback pre-pass and the in-loop final safety net.
- * The cases that matter: normal ROIs pass, non-positive dims fail, the
- * 100 MP boundary is inclusive, the real observed divergence (8171×12336)
- * is caught, and a ROI whose int32 area would overflow is still caught.
- */
-#include "warp_guard.hpp"
-
-#include <gtest/gtest.h>
-
-using retailens::warpRoiExceedsGuard;
-
-TEST(WarpGuard, AcceptsNormalRoi) {
-  EXPECT_FALSE(warpRoiExceedsGuard(4000, 2000));  // 8 MP
-  EXPECT_FALSE(warpRoiExceedsGuard(1, 1));
-}
-
-TEST(WarpGuard, RejectsNonPositiveDims) {
-  EXPECT_TRUE(warpRoiExceedsGuard(0, 1000));
-  EXPECT_TRUE(warpRoiExceedsGuard(1000, 0));
-  EXPECT_TRUE(warpRoiExceedsGuard(-5, 1000));
-  EXPECT_TRUE(warpRoiExceedsGuard(1000, -5));
-}
-
-TEST(WarpGuard, BoundaryIsInclusive) {
-  EXPECT_FALSE(warpRoiExceedsGuard(100000, 1000));  // exactly 100 MP — allowed
-  EXPECT_TRUE(warpRoiExceedsGuard(100000, 1001));   // 100.1 MP — over
-}
-
-TEST(WarpGuard, RejectsTheObservedDivergence) {
-  // 8171×12336 = 100.8 MP — the exact STITCH_CAMERA_PARAMS_FAIL canvas.
-  EXPECT_TRUE(warpRoiExceedsGuard(8171, 12336));
-}
-
-TEST(WarpGuard, RejectsInt32OverflowingRoi) {
-  // 65536×65536 = 2^32; an int32 area would wrap to 0 and slip past the
-  // guard. The int64 area math catches it.
-  EXPECT_TRUE(warpRoiExceedsGuard(65536, 65536));
-}
-
-TEST(WarpGuard, HonoursCustomThreshold) {
-  EXPECT_FALSE(warpRoiExceedsGuard(1000, 1000, 2'000'000));  // 1 MP < 2 MP
-  EXPECT_TRUE(warpRoiExceedsGuard(2000, 1000, 1'000'000));   // 2 MP > 1 MP
-}

package/src/camera/__tests__/PanoramaSettingsBridge.test.ts

@@ -1,190 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for the JS→native settings bridge.
- *
- * Scope: every adapter (panoramaSettingsToNativeConfig,
- * slitscanSettingsToNativeConfig, hybridSettingsToNativeConfig)
- * round-trip from a hierarchical typed input to the flat wire dict
- * the native side reads.  Asserts both:
- *
- *   1. Naming — JS key `registration.ncc1d.searchRadius` becomes
- *      native key `nccSearchRadius1d` (and similar mappings).  Each
- *      DEFAULT_* snapshot's expected wire dict is enumerated below;
- *      drift in either direction (lib drops a key, or adds a phantom
- *      one) is caught here.
- *
- *   2. Presence-as-enable — undefined optional sub-objects in the
- *      typed shape (`registration.ncc1d`, `registration.ncc2d`,
- *      `registration.ncc2d.emaSmoothing`, `registration.ncc2d.panAxisLock`,
- *      `frameSelection.flow`, `advanced`) translate to explicit
- *      `enable*: false` (or the absence of all the sub-object's
- *      payload keys) on the wire.  Many of these have been silent
- *      drift hazards historically — the old flat type required the
- *      consumer to set BOTH `enable1dNcc: true` AND `nccSearchRadius1d:
- *      <value>`; v0.4 makes them inseparable by collapsing into a
- *      single optional sub-object, and this file is what guarantees
- *      the wire side still gets both halves.
- *
- *   3. Engine-discriminated coverage — plane source variants
- *      ('Disabled' / 'ARKitDetected' / 'Virtual') gate which optional
- *      plane fields are emitted; the bridge filters those at the
- *      adapter boundary so the modal's per-source rendering doesn't
- *      get mislead by stale-but-present keys from a previous source
- *      selection.
- *
- * These tests are pure-TS; no React Native module import.  Jest config
- * (`jest.config.js`) routes test files in `__tests__/` through ts-jest
- * with the `node` testEnvironment.
- */
-
-import {
-  DEFAULT_FLOW_GATE_SETTINGS,
-  DEFAULT_PANORAMA_SETTINGS,
-  type PanoramaSettings,
-} from '../PanoramaSettings';
-import {
-  panoramaSettingsToNativeConfig,
-} from '../PanoramaSettingsBridge';
-
-
-// ════════════════════════════════════════════════════════════════════
-// PANORAMA — batch-keyframe engine
-// ════════════════════════════════════════════════════════════════════
-
-describe('panoramaSettingsToNativeConfig', () => {
-  it('round-trips DEFAULT_PANORAMA_SETTINGS to the expected flat dict', () => {
-    const cfg = panoramaSettingsToNativeConfig(DEFAULT_PANORAMA_SETTINGS);
-
-    // Cross-cutting
-    expect(cfg.captureSource).toBe('ar');
-
-    // BatchStitcherSettings
-    expect(cfg.stitchMode).toBe('auto');
-    expect(cfg.warperType).toBe('plane');
-    expect(cfg.blenderType).toBe('multiband');
-    expect(cfg.seamFinderType).toBe('graphcut');
-    expect(cfg.enableMaxInscribedRectCrop).toBe(false);
-
-    // FrameSelectionSettings
-    expect(cfg.frameSelectionMode).toBe('flow-based');
-    expect(cfg.keyframeMaxCount).toBe(6);
-    expect(cfg.keyframeOverlapThreshold).toBe(0.2);
-    expect(cfg.maxKeyframeIntervalMs).toBe(2000);
-
-    // FlowGateSettings (flow is defined in the default)
-    expect(cfg.flowNoveltyPercentile).toBe(0.85);
-    expect(cfg.flowEvalEveryNFrames).toBe(5);
-    expect(cfg.flowMaxTranslationCm).toBe(50);
-    expect(cfg.flowMaxCorners).toBe(150);
-    expect(cfg.flowQualityLevel).toBe(0.01);
-    expect(cfg.flowMinDistance).toBe(10);
-  });
-
-  it('falls back to DEFAULT_FLOW_GATE_SETTINGS when frameSelection.flow is undefined', () => {
-    // F10 Phase 2 review B1 — native compiled-in defaults disagree
-    // with the JS defaults for two flow knobs (maxTranslationCm and
-    // evalEveryNFrames).  The bridge must always emit every flow key
-    // so sparse-literal hosts get the JS defaults on the wire, not
-    // the native fallbacks.
-    const noFlow: PanoramaSettings = {
-      ...DEFAULT_PANORAMA_SETTINGS,
-      frameSelection: {
-        ...DEFAULT_PANORAMA_SETTINGS.frameSelection,
-        flow: undefined,
-      },
-    };
-    const cfg = panoramaSettingsToNativeConfig(noFlow);
-
-    expect(cfg.frameSelectionMode).toBe('flow-based');
-    expect(cfg.keyframeMaxCount).toBe(6);
-    expect(cfg.keyframeOverlapThreshold).toBe(0.2);
-
-    // Every flow.* native key present, matching DEFAULT_FLOW_GATE_SETTINGS.
-    expect(cfg.flowNoveltyPercentile).toBe(DEFAULT_FLOW_GATE_SETTINGS.noveltyPercentile);
-    expect(cfg.flowEvalEveryNFrames).toBe(DEFAULT_FLOW_GATE_SETTINGS.evalEveryNFrames);
-    expect(cfg.flowMaxTranslationCm).toBe(DEFAULT_FLOW_GATE_SETTINGS.maxTranslationCm);
-    expect(cfg.flowMaxCorners).toBe(DEFAULT_FLOW_GATE_SETTINGS.maxCorners);
-    expect(cfg.flowQualityLevel).toBe(DEFAULT_FLOW_GATE_SETTINGS.qualityLevel);
-    expect(cfg.flowMinDistance).toBe(DEFAULT_FLOW_GATE_SETTINGS.minDistance);
-  });
-
-  it('emits flow defaults to the wire when frameSelection.flow is undefined AND mode is flow-based', () => {
-    // F10 Phase 2 review N3 — the realistic user-facing case:
-    // host writes `mode: 'flow-based'` but omits the flow sub-tree.
-    // Pre-B1-fix, the gate would silently run with native fallbacks
-    // (flowMaxTranslationCm=0, flowEvalEveryNFrames=1) instead of
-    // the JS defaults (50 cm budget, 5× throttle).
-    const s: PanoramaSettings = {
-      ...DEFAULT_PANORAMA_SETTINGS,
-      frameSelection: {
-        mode: 'flow-based',
-        maxKeyframes: 6,
-        overlapThreshold: 0.20,
-        maxKeyframeIntervalMs: 2000,
-        // flow omitted — legal per the optional `?` in the type
-      },
-    };
-    const cfg = panoramaSettingsToNativeConfig(s);
-
-    expect(cfg.flowMaxTranslationCm).toBe(50);
-    expect(cfg.flowEvalEveryNFrames).toBe(5);
-    expect(cfg.flowNoveltyPercentile).toBe(0.85);
-    expect(cfg.flowMaxCorners).toBe(150);
-    expect(cfg.flowQualityLevel).toBe(0.01);
-    expect(cfg.flowMinDistance).toBe(10);
-  });
-
-  it('locks down the full wire-key set for DEFAULT_PANORAMA_SETTINGS', () => {
-    // F10 Phase 2 review N4 — mirror the hybrid test below.  Lock
-    // down which keys leave the bridge so a future field accidentally
-    // riding along (e.g. `debug` being treated as a wire knob) fails
-    // this test immediately.
-    const cfg = panoramaSettingsToNativeConfig(DEFAULT_PANORAMA_SETTINGS);
-    expect(Object.keys(cfg).sort()).toEqual([
-      'blenderType',
-      'captureSource',
-      'enableMaxInscribedRectCrop',
-      'flowEvalEveryNFrames',
-      'flowMaxCorners',
-      'flowMaxTranslationCm',
-      'flowMinDistance',
-      'flowNoveltyPercentile',
-      'flowQualityLevel',
-      'frameSelectionMode',
-      'keyframeMaxCount',
-      'keyframeOverlapThreshold',
-      'maxKeyframeIntervalMs',
-      'seamFinderType',
-      'stitchMode',
-      'warperType',
-    ]);
-  });
-
-  it('honours captureSource and stitcher overrides', () => {
-    const overridden: PanoramaSettings = {
-      ...DEFAULT_PANORAMA_SETTINGS,
-      captureSource: 'non-ar',
-      debug: true,
-      stitcher: {
-        stitchMode: 'scans',
-        warperType: 'spherical',
-        blenderType: 'feather',
-        seamFinderType: 'skip',
-        enableMaxInscribedRectCrop: true,
-      },
-    };
-    const cfg = panoramaSettingsToNativeConfig(overridden);
-
-    expect(cfg.captureSource).toBe('non-ar');
-    expect(cfg.stitchMode).toBe('scans');
-    expect(cfg.warperType).toBe('spherical');
-    expect(cfg.blenderType).toBe('feather');
-    expect(cfg.seamFinderType).toBe('skip');
-    expect(cfg.enableMaxInscribedRectCrop).toBe(true);
-    // Note: `debug` is intentionally NOT on the wire — it's a
-    // JS-side UI gate, not a native config knob.  The bridge MUST
-    // omit it; if a future change starts emitting it, the modal's
-    // operator-facing semantics will silently drift.
-    expect(cfg).not.toHaveProperty('debug');
-  });
-});

package/src/camera/__tests__/bandThumbRotation.test.ts

@@ -1,120 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for the band/tile orientation-decision functions in
- * `PanoramaBandOverlay` — the pure logic behind the v0.13.1 EXIF
- * double-rotation fix.
- *
- * Why test the pure functions, not a render: the lib's jest config is
- * pure-TS (`ts-jest` + node env, no `@testing-library/react-native`;
- * see jest.config.js header).  The orientation contract lives entirely
- * in `bandThumbRotation` / `tileRotation`, which the component now calls
- * directly — so exercising them here covers the real code path.
- *
- * The bug these guard against:
- *   Saved `keyframe-N.jpg` files are sensor-native LANDSCAPE pixels with
- *   EXIF Orientation = 6 ("rotate 90° CW").  RN's <Image> auto-rotates
- *   them upright.  v0.12 ALSO applied a JS rotate transform to the tiles
- *   → double-rotation → thumbnails 90° off in portrait-locked landscape.
- *   The fix: tiles get NO transform in the portrait-locked
- *   (vertical=false) path; the single cumulative thumb (no EXIF) still
- *   does.
- */
-
-// Mock react-native so importing the SUT module doesn't pull the native
-// StyleSheet/Image bridge (we only call the pure functions).  Matches
-// the mocking approach in useOrientationDrift.test.ts.
-jest.mock('react-native', () => ({
-  Image: 'Image',
-  ScrollView: 'ScrollView',
-  StyleSheet: { create: (s: Record<string, unknown>) => s, absoluteFill: {} },
-  Text: 'Text',
-  View: 'View',
-}));
-
-import {
-  _bandThumbRotationForTests as bandThumbRotation,
-  _tileRotationForTests as tileRotation,
-  type BandCaptureOrientation,
-} from '../PanoramaBandOverlay';
-
-const PORTRAIT: BandCaptureOrientation = 'portrait';
-const UPSIDE: BandCaptureOrientation = 'portrait-upside-down';
-const LEFT: BandCaptureOrientation = 'landscape-left';
-const RIGHT: BandCaptureOrientation = 'landscape-right';
-
-describe('bandThumbRotation — single cumulative thumb (no EXIF source)', () => {
-  describe('vertical=false (portrait-locked UI)', () => {
-    it('does not rotate in portrait', () => {
-      expect(bandThumbRotation(PORTRAIT, false)).toBeUndefined();
-    });
-
-    it('does not rotate in portrait-upside-down', () => {
-      expect(bandThumbRotation(UPSIDE, false)).toBeUndefined();
-    });
-
-    it('rotates 90° CW for landscape-left', () => {
-      expect(bandThumbRotation(LEFT, false)).toEqual([{ rotate: '90deg' }]);
-    });
-
-    it('rotates 90° CCW for landscape-right (opposite sign of left)', () => {
-      expect(bandThumbRotation(RIGHT, false)).toEqual([{ rotate: '-90deg' }]);
-    });
-  });
-
-  describe('vertical=true (non-locked, OS-rotated framebuffer)', () => {
-    it('does not rotate in portrait', () => {
-      expect(bandThumbRotation(PORTRAIT, true)).toBeUndefined();
-    });
-
-    it('uses the OPPOSITE sign from the portrait-locked case (left)', () => {
-      // vertical=false → 90deg, so vertical=true → -90deg.
-      expect(bandThumbRotation(LEFT, true)).toEqual([{ rotate: '-90deg' }]);
-      expect(bandThumbRotation(LEFT, true)).not.toEqual(
-        bandThumbRotation(LEFT, false),
-      );
-    });
-
-    it('uses the OPPOSITE sign from the portrait-locked case (right)', () => {
-      expect(bandThumbRotation(RIGHT, true)).toEqual([{ rotate: '90deg' }]);
-      expect(bandThumbRotation(RIGHT, true)).not.toEqual(
-        bandThumbRotation(RIGHT, false),
-      );
-    });
-  });
-});
-
-describe('tileRotation — per-keyframe tiles (EXIF-6 source, the fix)', () => {
-  describe('vertical=false (portrait-locked) — the regression case', () => {
-    it.each<[BandCaptureOrientation]>([
-      [PORTRAIT],
-      [UPSIDE],
-      [LEFT],
-      [RIGHT],
-    ])(
-      'applies NO transform for %s (EXIF already auto-rotates → no double-rotate)',
-      (orientation) => {
-        expect(tileRotation(orientation, false)).toBeUndefined();
-      },
-    );
-
-    it('specifically does NOT rotate landscape tiles (the v0.12 bug)', () => {
-      // Pre-fix this returned [{rotate:'90deg'}] / [{rotate:'-90deg'}]
-      // on top of the EXIF auto-rotate → tiles 90° off.  Must be undefined.
-      expect(tileRotation(LEFT, false)).toBeUndefined();
-      expect(tileRotation(RIGHT, false)).toBeUndefined();
-    });
-  });
-
-  describe('vertical=true (non-locked landscape) — transform still needed', () => {
-    it('matches bandThumbRotation in the vertical path', () => {
-      // In the OS-rotated case the box is landscape JS coords, 90° off
-      // the EXIF-upright tile, so the compensation IS required.
-      expect(tileRotation(LEFT, true)).toEqual(bandThumbRotation(LEFT, true));
-      expect(tileRotation(RIGHT, true)).toEqual(bandThumbRotation(RIGHT, true));
-    });
-
-    it('does not rotate in portrait even when vertical', () => {
-      expect(tileRotation(PORTRAIT, true)).toBeUndefined();
-    });
-  });
-});