react-native-image-stitcher 0.15.2 → 0.16.0

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

@@ -1,160 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for buildPanoramaInitialSettings — the prop→settings-tree
- * translation that runs once at <Camera>'s mount.
- *
- * Coverage:
- *
- *   - Defaults (no prop overrides) reproduce DEFAULT_PANORAMA_SETTINGS
- *     when `isLowMemDevice=false`.
- *   - `isLowMemDevice=true` swaps blender + seamFinder defaults to the
- *     feather+skip fallback; other fields unchanged.
- *   - Every prop override routes to its hierarchical path: stitchMode →
- *     stitcher.stitchMode, defaultFlowMaxTranslationCm →
- *     frameSelection.flow.maxTranslationCm, etc.
- *   - Partial overrides leave non-overridden fields at the default.
- *
- * Plus a "wire-format integration" check: the produced settings tree,
- * fed through `panoramaSettingsToNativeConfig`, lands at the expected
- * flat dict.  This is the seam where the prop translation, the
- * hierarchical tree, and the bridge all meet — verifying it here means
- * <Camera>'s `incremental.start({ config })` call is correctly wired
- * end-to-end on the JS side (on-device run remains the integration
- * check across the JS/native boundary itself).
- */
-
-import {
-  DEFAULT_PANORAMA_SETTINGS,
-  type PanoramaSettings,
-} from '../PanoramaSettings';
-import { panoramaSettingsToNativeConfig } from '../PanoramaSettingsBridge';
-import { buildPanoramaInitialSettings } from '../buildPanoramaInitialSettings';
-
-
-describe('buildPanoramaInitialSettings', () => {
-  it('returns DEFAULT_PANORAMA_SETTINGS verbatim when no overrides and not low-mem', () => {
-    const s = buildPanoramaInitialSettings({}, false);
-    expect(s).toEqual(DEFAULT_PANORAMA_SETTINGS);
-  });
-
-  it('swaps blender + seamFinder for the low-mem fallback', () => {
-    const s = buildPanoramaInitialSettings({}, true);
-    expect(s.stitcher.blenderType).toBe('feather');
-    expect(s.stitcher.seamFinderType).toBe('skip');
-    // Everything else stays at the static default.
-    expect(s.stitcher.stitchMode).toBe(DEFAULT_PANORAMA_SETTINGS.stitcher.stitchMode);
-    expect(s.stitcher.warperType).toBe(DEFAULT_PANORAMA_SETTINGS.stitcher.warperType);
-    expect(s.frameSelection).toEqual(DEFAULT_PANORAMA_SETTINGS.frameSelection);
-    expect(s.captureSource).toBe(DEFAULT_PANORAMA_SETTINGS.captureSource);
-  });
-
-  it('routes every prop override to its hierarchical path', () => {
-    const s = buildPanoramaInitialSettings(
-      {
-        defaultCaptureSource: 'non-ar',
-        defaultStitchMode: 'scans',
-        defaultBlender: 'feather',
-        defaultSeamFinder: 'skip',
-        defaultWarper: 'cylindrical',
-        defaultFlowNoveltyPercentile: 0.70,
-        defaultFlowEvalEveryNFrames: 3,
-        defaultFlowMaxTranslationCm: 12,
-        defaultKeyframeMaxCount: 8,
-        defaultKeyframeOverlapThreshold: 0.30,
-        maxInscribedRectCrop: true,
-      },
-      false,
-    );
-
-    expect(s.captureSource).toBe('non-ar');
-    expect(s.stitcher.stitchMode).toBe('scans');
-    expect(s.stitcher.blenderType).toBe('feather');
-    expect(s.stitcher.seamFinderType).toBe('skip');
-    expect(s.stitcher.warperType).toBe('cylindrical');
-    expect(s.frameSelection.flow?.noveltyPercentile).toBe(0.70);
-    expect(s.frameSelection.flow?.evalEveryNFrames).toBe(3);
-    expect(s.frameSelection.flow?.maxTranslationCm).toBe(12);
-    expect(s.frameSelection.maxKeyframes).toBe(8);
-    expect(s.frameSelection.overlapThreshold).toBe(0.30);
-    expect(s.stitcher.enableMaxInscribedRectCrop).toBe(true);
-  });
-
-  it('maps maxInscribedRectCrop → stitcher.enableMaxInscribedRectCrop', () => {
-    expect(
-      buildPanoramaInitialSettings({ maxInscribedRectCrop: true }, false)
-        .stitcher.enableMaxInscribedRectCrop,
-    ).toBe(true);
-    expect(
-      buildPanoramaInitialSettings({ maxInscribedRectCrop: false }, false)
-        .stitcher.enableMaxInscribedRectCrop,
-    ).toBe(false);
-    // Omitted ⇒ default (false — inscribed-rect crop is opt-in), and the
-    // low-mem fallback must not flip it.
-    expect(
-      buildPanoramaInitialSettings({}, false)
-        .stitcher.enableMaxInscribedRectCrop,
-    ).toBe(false);
-    expect(
-      buildPanoramaInitialSettings({}, true)
-        .stitcher.enableMaxInscribedRectCrop,
-    ).toBe(false);
-  });
-
-  it('maps defaultMaxKeyframeIntervalMs → frameSelection.maxKeyframeIntervalMs', () => {
-    expect(
-      buildPanoramaInitialSettings({ defaultMaxKeyframeIntervalMs: 3500 }, false)
-        .frameSelection.maxKeyframeIntervalMs,
-    ).toBe(3500);
-    // 0 explicitly disables the time-budget force-accept — it is NOT
-    // nullish, so `??` does not replace it with the default.
-    expect(
-      buildPanoramaInitialSettings({ defaultMaxKeyframeIntervalMs: 0 }, false)
-        .frameSelection.maxKeyframeIntervalMs,
-    ).toBe(0);
-    // Omitted ⇒ the 2000 ms default.
-    expect(
-      buildPanoramaInitialSettings({}, false)
-        .frameSelection.maxKeyframeIntervalMs,
-    ).toBe(2000);
-  });
-
-  it('leaves non-overridden fields at the default (partial override)', () => {
-    const s = buildPanoramaInitialSettings(
-      { defaultStitchMode: 'panorama' },
-      false,
-    );
-
-    // The override took effect …
-    expect(s.stitcher.stitchMode).toBe('panorama');
-
-    // … and every other field stays at the corresponding default.
-    expect(s.stitcher.warperType).toBe(DEFAULT_PANORAMA_SETTINGS.stitcher.warperType);
-    expect(s.stitcher.blenderType).toBe(DEFAULT_PANORAMA_SETTINGS.stitcher.blenderType);
-    expect(s.stitcher.seamFinderType).toBe(DEFAULT_PANORAMA_SETTINGS.stitcher.seamFinderType);
-    expect(s.frameSelection).toEqual(DEFAULT_PANORAMA_SETTINGS.frameSelection);
-    expect(s.captureSource).toBe(DEFAULT_PANORAMA_SETTINGS.captureSource);
-  });
-
-  it('produces wire-format-clean output when piped through the bridge', () => {
-    // The end-to-end JS-side path: props → buildPanoramaInitialSettings →
-    // panoramaSettingsToNativeConfig.  Verifying it here catches drift
-    // at any of the three layers (prop name, type-tree shape, bridge
-    // adapter) with a single assertion.
-    const overrides = {
-      defaultCaptureSource: 'non-ar' as const,
-      defaultStitchMode: 'scans' as const,
-      defaultFlowMaxTranslationCm: 25,
-    };
-    const settings: PanoramaSettings =
-      buildPanoramaInitialSettings(overrides, false);
-    const wire = panoramaSettingsToNativeConfig(settings);
-
-    expect(wire.captureSource).toBe('non-ar');
-    expect(wire.stitchMode).toBe('scans');
-    expect(wire.flowMaxTranslationCm).toBe(25);
-    // Defaulted fields still on the wire with their default value.
-    expect(wire.warperType).toBe('plane');
-    expect(wire.frameSelectionMode).toBe('flow-based');
-    expect(wire.flowNoveltyPercentile).toBe(0.85);
-  });
-});

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

@@ -1,76 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for the recoverable-stitch-failure guidance map.
- *
- * Guarantees: (1) every recoverable code yields non-empty, plain-language
- * copy with no raw cv::Stitcher diagnostic leaking through; (2) the
- * cause-specific guidance actually names its corrective action; (3) every
- * non-recoverable code returns null so the host falls back to its generic
- * error UI.
- */
-import { userFacingStitchError } from '../cameraErrorMessages';
-import type { CameraErrorCode } from '../Camera';
-
-describe('userFacingStitchError', () => {
-  const RECOVERABLE: CameraErrorCode[] = [
-    'STITCH_NEED_MORE_IMGS',
-    'STITCH_HOMOGRAPHY_FAIL',
-    'STITCH_CAMERA_PARAMS_FAIL',
-    'STITCH_OOM',
-  ];
-
-  it.each(RECOVERABLE)(
-    'returns non-empty, jargon-free title+message for %s',
-    (code) => {
-      const r = userFacingStitchError(code);
-      expect(r).not.toBeNull();
-      expect(r!.title.length).toBeGreaterThan(0);
-      expect(r!.message.length).toBeGreaterThan(0);
-      // No raw stitcher diagnostics should ever reach the user.
-      expect(r!.message).not.toMatch(/warpRoi|cv::|OpenCV|ERR_|StsOutOfRange|estimator/i);
-      expect(r!.title).not.toMatch(/cv::|OpenCV|ERR_/i);
-      // The title is the corrective ASK (e.g. "Please pan more slowly"),
-      // not a generic failure headline.
-      expect(r!.title).not.toMatch(/couldn't|can't|error|failed|too large/i);
-    },
-  );
-
-  it('camera-params guidance names the 0.5x sensitivity and the 1x fix', () => {
-    const r = userFacingStitchError('STITCH_CAMERA_PARAMS_FAIL');
-    expect(r).not.toBeNull();
-    // The actual root cause (translation) + the actionable lens advice.
-    expect(r!.message).toMatch(/0\.5x|ultra-wide/i);
-    expect(r!.message).toMatch(/\b1x\b/i);
-    expect(r!.message).toMatch(/pivot|turning|one spot|moved|shifted/i);
-  });
-
-  it('need-more-images guidance is about overlap', () => {
-    expect(userFacingStitchError('STITCH_NEED_MORE_IMGS')!.message).toMatch(
-      /overlap/i,
-    );
-  });
-
-  it('oom guidance suggests a shorter sweep', () => {
-    expect(userFacingStitchError('STITCH_OOM')!.message).toMatch(
-      /shorter|narrower|memory/i,
-    );
-  });
-
-  const NON_RECOVERABLE: CameraErrorCode[] = [
-    'CAMERA_PERMISSION_DENIED',
-    'CAMERA_DEVICE_UNAVAILABLE',
-    'PHOTO_CAPTURE_FAILED',
-    'PANORAMA_START_FAILED',
-    'PANORAMA_FINALIZE_FAILED',
-    'OUTPUT_WRITE_FAILED',
-    'VISION_CAMERA_RUNTIME',
-    'UNKNOWN',
-  ];
-
-  it.each(NON_RECOVERABLE)(
-    'returns null for non-recoverable code %s',
-    (code) => {
-      expect(userFacingStitchError(code)).toBeNull();
-    },
-  );
-});

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

@@ -1,116 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for `homeIndicatorEdge` + `isSideEdge` — the pure functions
- * that produce the `vertical` flag driving PanoramaBandOverlay and
- * CaptureThumbnailStrip layout under non-locked hosts.
- *
- *   vertical = isSideEdge(homeIndicatorEdge(jsLandscape, deviceOrient))
- *
- * Contract (v0.12 orientation-aware Camera):
- *   - Portrait JS layout (jsLandscape=false) → 'bottom' edge → NOT a
- *     side edge → vertical=false (horizontal strip, the portrait-locked
- *     case that's the recommended config).
- *   - Landscape JS layout → 'right'/'left' edge → side edge →
- *     vertical=true (the strip/band stack along the home-indicator edge).
- *
- * Pure-TS test per jest.config.js (no component mount).  The functions
- * are imported via Camera.tsx's `_*ForTests` handles; react-native and
- * the heavy native deps are mocked so the import resolves in node env.
- */
-
-// The SUT lives in Camera.tsx, which transitively imports the entire
-// camera surface (vision-camera, worklets, sensors, native modules).
-// We only call two pure functions, so stub the whole dependency tree.
-jest.mock('react-native', () => ({
-  NativeModules: {},
-  Platform: { OS: 'ios', select: (o: Record<string, unknown>) => o.ios },
-  Pressable: 'Pressable',
-  StyleSheet: { create: (s: Record<string, unknown>) => s, absoluteFill: {} },
-  Text: 'Text',
-  View: 'View',
-  Image: 'Image',
-  ScrollView: 'ScrollView',
-  Animated: { View: 'Animated.View', Value: class {}, timing: () => ({ start: () => undefined }) },
-  Modal: 'Modal',
-  ActivityIndicator: 'ActivityIndicator',
-  useWindowDimensions: () => ({ width: 0, height: 0 }),
-  requireNativeComponent: () => 'NativeComponent',
-  UIManager: { getViewManagerConfig: () => ({}) },
-  findNodeHandle: () => 1,
-}));
-jest.mock('react-native-safe-area-context', () => ({
-  useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 }),
-}));
-jest.mock('react-native-sensors', () => ({
-  accelerometer: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
-  setUpdateIntervalForType: jest.fn(),
-  SensorTypes: { accelerometer: 'accelerometer' },
-}));
-jest.mock('react-native-worklets-core', () => ({ Worklets: {} }));
-jest.mock('react-native-vision-camera', () => ({
-  Camera: 'Camera',
-  useCameraDevice: jest.fn(),
-  useCameraPermission: jest.fn(),
-}));
-
-import {
-  _homeIndicatorEdgeForTests as homeIndicatorEdge,
-  _isSideEdgeForTests as isSideEdge,
-} from '../Camera';
-import type { DeviceOrientation } from '../useDeviceOrientation';
-
-const PORTRAIT: DeviceOrientation = 'portrait';
-const UPSIDE: DeviceOrientation = 'portrait-upside-down';
-const LEFT: DeviceOrientation = 'landscape-left';
-const RIGHT: DeviceOrientation = 'landscape-right';
-
-// The composed signal the band/strip actually consume.
-const vertical = (jsLandscape: boolean, o: DeviceOrientation) =>
-  isSideEdge(homeIndicatorEdge(jsLandscape, o));
-
-describe('homeIndicatorEdge', () => {
-  it('returns bottom for any portrait JS layout (jsLandscape=false)', () => {
-    // Portrait JS layout always anchors bottom regardless of the sensor
-    // value — this is the portrait-locked case (the recommended config).
-    for (const o of [PORTRAIT, UPSIDE, LEFT, RIGHT]) {
-      expect(homeIndicatorEdge(false, o)).toBe('bottom');
-    }
-  });
-
-  it('anchors RIGHT for landscape-left device in landscape JS layout', () => {
-    expect(homeIndicatorEdge(true, LEFT)).toBe('right');
-  });
-
-  it('anchors LEFT for landscape-right device in landscape JS layout', () => {
-    expect(homeIndicatorEdge(true, RIGHT)).toBe('left');
-  });
-
-  it('falls through to right for non-landscape sensor + landscape JS (transient)', () => {
-    // jsLandscape=true with a portrait sensor reading only happens
-    // mid-rotation; defensive default is 'right'.
-    expect(homeIndicatorEdge(true, PORTRAIT)).toBe('right');
-    expect(homeIndicatorEdge(true, UPSIDE)).toBe('right');
-  });
-});
-
-describe('isSideEdge', () => {
-  it('is true only for left/right edges', () => {
-    expect(isSideEdge('left')).toBe(true);
-    expect(isSideEdge('right')).toBe(true);
-    expect(isSideEdge('bottom')).toBe(false);
-    expect(isSideEdge('top')).toBe(false);
-  });
-});
-
-describe('vertical flag (composed) — what the strip/band consume', () => {
-  it('is FALSE for portrait-locked layout (horizontal strip, recommended)', () => {
-    for (const o of [PORTRAIT, UPSIDE, LEFT, RIGHT]) {
-      expect(vertical(false, o)).toBe(false);
-    }
-  });
-
-  it('is TRUE for both landscape orientations under a non-locked host', () => {
-    expect(vertical(true, LEFT)).toBe(true);
-    expect(vertical(true, RIGHT)).toBe(true);
-  });
-});

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

@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for the pure `isBelowMemThreshold` classifier.
- *
- * The other two exports (`getPhysicalMemoryBytes` and `isLowMemDevice`)
- * read the React Native bridge and can only be exercised on a real
- * device.  This file covers the threshold logic exhaustively so the
- * classification rule is unit-tested without needing the RN runtime.
- */
-
-import {
-  LOW_MEM_THRESHOLD_BYTES,
-  isBelowMemThreshold,
-} from '../lowMemDevice';
-
-
-describe('isBelowMemThreshold', () => {
-  it('returns true for positive byte counts below the threshold', () => {
-    expect(isBelowMemThreshold(1)).toBe(true);
-    expect(isBelowMemThreshold(1024)).toBe(true);
-    expect(isBelowMemThreshold(LOW_MEM_THRESHOLD_BYTES - 1)).toBe(true);
-  });
-
-  it('returns false at exactly the threshold (strict < comparison)', () => {
-    expect(isBelowMemThreshold(LOW_MEM_THRESHOLD_BYTES)).toBe(false);
-  });
-
-  it('returns false for byte counts above the threshold', () => {
-    expect(isBelowMemThreshold(LOW_MEM_THRESHOLD_BYTES + 1)).toBe(false);
-    expect(isBelowMemThreshold(4 * 1024 * 1024 * 1024)).toBe(false);
-    expect(isBelowMemThreshold(Number.MAX_SAFE_INTEGER)).toBe(false);
-  });
-
-  it('returns false for zero (unknown — safe default to high-quality combo)', () => {
-    expect(isBelowMemThreshold(0)).toBe(false);
-  });
-
-  it('returns false for negative values (defensive)', () => {
-    expect(isBelowMemThreshold(-1)).toBe(false);
-    expect(isBelowMemThreshold(-LOW_MEM_THRESHOLD_BYTES)).toBe(false);
-  });
-
-  it('returns false for non-finite values (NaN / Infinity)', () => {
-    expect(isBelowMemThreshold(Number.NaN)).toBe(false);
-    expect(isBelowMemThreshold(Number.POSITIVE_INFINITY)).toBe(false);
-    expect(isBelowMemThreshold(Number.NEGATIVE_INFINITY)).toBe(false);
-  });
-
-  it('threshold is exactly 2 GB', () => {
-    expect(LOW_MEM_THRESHOLD_BYTES).toBe(2 * 1024 * 1024 * 1024);
-  });
-});

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

@@ -1,210 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for `selectCaptureDevice` + `zoomForLens` — the pure
- * capability-aware back-camera selection (v0.13.2).
- *
- * Covers the device matrix from the plan
- * (docs/plans/2026-06-01-v0.13.2-multilens-device-selection.md),
- * including the critical edge cases:
- *   - ultra-wide ONLY inside a multi-cam device (Symptom 1 fix)
- *   - ultra-wide ONLY as a standalone device (Android; must NOT regress)
- *   - ultra-wide present BOTH ways (prefer multicam)
- *
- * Pure — no mocks needed; we build synthetic DeviceLike lists.
- */
-
-import {
-  selectCaptureDevice,
-  zoomForLens,
-  type DeviceLike,
-} from '../selectCaptureDevice';
-
-// ── Synthetic device builders ───────────────────────────────────────
-let idCounter = 0;
-function dev(partial: Partial<DeviceLike>): DeviceLike {
-  idCounter += 1;
-  return {
-    id: `dev-${idCounter}`,
-    position: 'back',
-    physicalDevices: ['wide-angle-camera'],
-    isMultiCam: false,
-    hasTorch: true,
-    minZoom: 1,
-    neutralZoom: 1,
-    maxZoom: 10,
-    ...partial,
-  };
-}
-
-const tripleCam = (p: Partial<DeviceLike> = {}) =>
-  dev({
-    physicalDevices: ['ultra-wide-angle-camera', 'wide-angle-camera', 'telephoto-camera'],
-    isMultiCam: true,
-    hasTorch: true,
-    minZoom: 0.5,
-    neutralZoom: 1,
-    maxZoom: 30,
-    ...p,
-  });
-const dualWide = (p: Partial<DeviceLike> = {}) =>
-  dev({
-    physicalDevices: ['ultra-wide-angle-camera', 'wide-angle-camera'],
-    isMultiCam: true,
-    hasTorch: true,
-    minZoom: 0.5,
-    neutralZoom: 1,
-    maxZoom: 6,
-    ...p,
-  });
-const standaloneWide = (p: Partial<DeviceLike> = {}) =>
-  dev({ physicalDevices: ['wide-angle-camera'], isMultiCam: false, hasTorch: true, ...p });
-const standaloneUltraWide = (p: Partial<DeviceLike> = {}) =>
-  dev({ physicalDevices: ['ultra-wide-angle-camera'], isMultiCam: false, hasTorch: false, ...p });
-
-describe('selectCaptureDevice', () => {
-  it('picks the MULTICAM device when one spans wide + ultra-wide (triple cam)', () => {
-    const triple = tripleCam();
-    const sel = selectCaptureDevice([triple, standaloneWide(), standaloneUltraWide()]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(triple);
-    expect(sel.ultraWideDevice).toBeNull();
-    expect(sel.has0_5x).toBe(true);
-    expect(sel.hasTorch).toBe(true);
-  });
-
-  it('picks the MULTICAM device for a dual-wide grouping', () => {
-    const dual = dualWide();
-    const sel = selectCaptureDevice([dual, standaloneWide()]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(dual);
-    expect(sel.has0_5x).toBe(true);
-  });
-
-  it('SYMPTOM 1 FIX: ultra-wide ONLY in a multi-cam device → multicam (not wide fallback)', () => {
-    // The exact bug: a phone where ultra-wide is bundled in a multicam
-    // device and there is NO standalone ultra-wide.  Old single-lens
-    // filter fell back to wide-angle; we must pick the multicam.
-    const dual = dualWide();
-    const wide = standaloneWide();
-    const sel = selectCaptureDevice([wide, dual]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(dual);
-    expect(sel.has0_5x).toBe(true);
-  });
-
-  it('EDGE: ultra-wide ONLY as a standalone device (Android) → standalone-uw (no regression)', () => {
-    // No multicam grouping at all.  Must still expose 0.5× via the
-    // standalone ultra-wide, mounting the wide-angle as primary.
-    const wide = standaloneWide();
-    const uw = standaloneUltraWide();
-    const sel = selectCaptureDevice([wide, uw]);
-    expect(sel.mode).toBe('standalone-uw');
-    expect(sel.device).toBe(wide); // primary = torch-bearing wide
-    expect(sel.ultraWideDevice).toBe(uw);
-    expect(sel.has0_5x).toBe(true);
-    expect(sel.hasTorch).toBe(true); // the 1× mount has a torch
-  });
-
-  it('EDGE: ultra-wide present BOTH standalone AND in multicam → prefer multicam', () => {
-    const dual = dualWide();
-    const wide = standaloneWide();
-    const uw = standaloneUltraWide();
-    const sel = selectCaptureDevice([uw, wide, dual]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(dual);
-  });
-
-  it('wide-angle ONLY (no ultra-wide anywhere) → wide-only, no 0.5×', () => {
-    const wide = standaloneWide();
-    const sel = selectCaptureDevice([wide]);
-    expect(sel.mode).toBe('wide-only');
-    expect(sel.device).toBe(wide);
-    expect(sel.has0_5x).toBe(false);
-    expect(sel.ultraWideDevice).toBeNull();
-  });
-
-  it('prefers a TORCH-bearing multicam device over a torchless one', () => {
-    const noTorch = dualWide({ hasTorch: false });
-    const withTorch = tripleCam({ hasTorch: true });
-    const sel = selectCaptureDevice([noTorch, withTorch]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(withTorch);
-    expect(sel.hasTorch).toBe(true);
-  });
-
-  it('ignores front-facing devices', () => {
-    const front = dev({ position: 'front', physicalDevices: ['ultra-wide-angle-camera', 'wide-angle-camera'], isMultiCam: true });
-    const backWide = standaloneWide();
-    const sel = selectCaptureDevice([front, backWide]);
-    expect(sel.mode).toBe('wide-only'); // front multicam doesn't count
-    expect(sel.device).toBe(backWide);
-  });
-
-  it('empty device list → null device, wide-only, no 0.5×', () => {
-    const sel = selectCaptureDevice([]);
-    expect(sel.device).toBeNull();
-    expect(sel.mode).toBe('wide-only');
-    expect(sel.has0_5x).toBe(false);
-    expect(sel.hasTorch).toBe(false);
-  });
-
-  it('standalone-uw: primary prefers a torch-bearing wide when multiple wides exist', () => {
-    const wideNoTorch = standaloneWide({ hasTorch: false });
-    const wideTorch = standaloneWide({ hasTorch: true });
-    const uw = standaloneUltraWide();
-    const sel = selectCaptureDevice([wideNoTorch, uw, wideTorch]);
-    expect(sel.mode).toBe('standalone-uw');
-    expect(sel.device).toBe(wideTorch);
-    expect(sel.hasTorch).toBe(true);
-  });
-
-  it('S24: multicam LISTS ultra-wide but zoom cannot reach it (minZoom~1) + standalone uw swaps', () => {
-    // Samsung/Camera2: the logical device lists the ultra-wide but its zoom
-    // range starts at 1.0, so zoom cannot reach it.  A separate ultra-wide id
-    // exists -> keep the multicam for 1x (torch) and swap to the standalone
-    // ultra-wide on 0.5x.
-    const multicamNoReach = dualWide({ minZoom: 1, hasTorch: true });
-    const uw = standaloneUltraWide();
-    const sel = selectCaptureDevice([multicamNoReach, uw]);
-    expect(sel.mode).toBe('standalone-uw');
-    expect(sel.device).toBe(multicamNoReach); // 1x primary keeps the torch
-    expect(sel.ultraWideDevice).toBe(uw); // 0.5x swaps to the real ultra-wide
-    expect(sel.has0_5x).toBe(true);
-    expect(sel.hasTorch).toBe(true);
-  });
-
-  it('multicam lists ultra-wide, zoom cannot reach (minZoom~1), NO standalone uw -> hide', () => {
-    // The ultra-wide exists ONLY inside a non-zoomable logical device with no
-    // separate id to swap to -> undeliverable -> hide the chooser.
-    const multicamNoReach = dualWide({ minZoom: 1 });
-    const sel = selectCaptureDevice([multicamNoReach]);
-    expect(sel.mode).toBe('wide-only');
-    expect(sel.has0_5x).toBe(false);
-    expect(sel.ultraWideDevice).toBeNull();
-  });
-
-  it('minZoom threshold: <=0.7 zoom-switches, >0.7 falls through to swap', () => {
-    const atThreshold = dualWide({ minZoom: 0.7 });
-    expect(selectCaptureDevice([atThreshold]).mode).toBe('multicam');
-    const aboveThreshold = dualWide({ minZoom: 0.71 });
-    const uw = standaloneUltraWide();
-    expect(selectCaptureDevice([aboveThreshold, uw]).mode).toBe('standalone-uw');
-  });
-});
-
-describe('zoomForLens (multicam lens→zoom mapping)', () => {
-  const d = { minZoom: 0.5, neutralZoom: 1 };
-
-  it('maps 0.5× to the device minZoom (ultra-wide end)', () => {
-    expect(zoomForLens(d, '0.5x')).toBe(0.5);
-  });
-
-  it('maps 1× to the device neutralZoom (wide-angle baseline)', () => {
-    expect(zoomForLens(d, '1x')).toBe(1);
-  });
-
-  it('handles a device whose neutralZoom differs from 1', () => {
-    expect(zoomForLens({ minZoom: 0.6, neutralZoom: 2 }, '1x')).toBe(2);
-    expect(zoomForLens({ minZoom: 0.6, neutralZoom: 2 }, '0.5x')).toBe(0.6);
-  });
-});