react-native-image-stitcher 0.12.0 → 0.14.0

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

@@ -0,0 +1,177 @@
+// 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);
+  });
+});
+
+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);
+  });
+});

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

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Unit tests for `contentRotationDeg` — the pure rotation computation
+ * behind `useContentRotation`, which keeps control content (AR toggle,
+ * lens/zoom pill, flash, thumbnails) upright relative to gravity
+ * regardless of host portrait-lock state.
+ *
+ * Covers the full truth table from the hook's docstring plus the
+ * mid-rotation transients (jsLandscape=true with a non-landscape device
+ * reading, which can briefly happen while the OS catches up).
+ *
+ * Pure-TS test per jest.config.js.  `useContentRotation` transitively
+ * imports `useDeviceOrientation` → `react-native-sensors` (an ES module
+ * the no-RN-preset jest infra can't parse), so stub it before importing
+ * the SUT.  We only call the pure `contentRotationDeg` export.
+ */
+
+jest.mock('react-native-sensors', () => ({
+  accelerometer: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
+  gyroscope: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
+  setUpdateIntervalForType: jest.fn(),
+  SensorTypes: { accelerometer: 'accelerometer', gyroscope: 'gyroscope' },
+}));
+
+import { contentRotationDeg } from '../useContentRotation';
+
+describe('contentRotationDeg', () => {
+  // Locked-portrait host: jsLandscape is ALWAYS false (window dims stay
+  // portrait regardless of device tilt).  The OS doesn't rotate the
+  // framebuffer, so content rotation must match device-physical for
+  // labels to read upright.  THIS is the case task #5b targets.
+
+  it('locked-portrait + device-portrait → 0° (no-op)', () => {
+    expect(contentRotationDeg(false, 'portrait')).toBe(0);
+  });
+
+  it('locked-portrait + device-landscape-left → 90° (CW)', () => {
+    expect(contentRotationDeg(false, 'landscape-left')).toBe(90);
+  });
+
+  it('locked-portrait + device-landscape-right → -90° (CCW)', () => {
+    expect(contentRotationDeg(false, 'landscape-right')).toBe(-90);
+  });
+
+  it('locked-portrait + device-upside-down → 180°', () => {
+    expect(contentRotationDeg(false, 'portrait-upside-down')).toBe(180);
+  });
+
+  // Non-locked host + device-landscape: OS rotated the framebuffer for
+  // us; we must NOT double-rotate.  Net rotation must be 0.
+
+  it('non-locked + device-landscape-left (jsLandscape=true) → 0°', () => {
+    expect(contentRotationDeg(true, 'landscape-left')).toBe(0);
+  });
+
+  it('non-locked + device-landscape-right (jsLandscape=true) → 0°', () => {
+    expect(contentRotationDeg(true, 'landscape-right')).toBe(0);
+  });
+
+  it('non-locked + device-portrait (jsLandscape=false) → 0°', () => {
+    expect(contentRotationDeg(false, 'portrait')).toBe(0);
+  });
+
+  // Mid-rotation transients: jsLandscape=true with a non-landscape
+  // device reading.  Falls through to 0 framebuffer rotation and
+  // applies device rotation directly; settles once the transient clears.
+
+  it('jsLandscape=true mid-rotation with device-portrait → 0°', () => {
+    expect(contentRotationDeg(true, 'portrait')).toBe(0);
+  });
+
+  it('jsLandscape=true mid-rotation with device-upside-down → 180°', () => {
+    expect(contentRotationDeg(true, 'portrait-upside-down')).toBe(180);
+  });
+
+  it('all returned values are in {0, 90, -90, 180} (no off-by-360°)', () => {
+    const orientations = [
+      'portrait',
+      'portrait-upside-down',
+      'landscape-left',
+      'landscape-right',
+    ] as const;
+    for (const o of orientations) {
+      for (const jsl of [true, false]) {
+        expect([0, 90, -90, 180]).toContain(contentRotationDeg(jsl, o));
+      }
+    }
+  });
+});

package/src/camera/selectCaptureDevice.ts

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * selectCaptureDevice — capability-aware back-camera selection.
+ *
+ * Replaces the single-physical-device request that caused two
+ * user-visible bugs (see docs/plans/2026-06-01-v0.13.2-multilens-
+ * device-selection.md):
+ *
+ *   1. 0.5× silently showed the wide-angle FOV on phones where the
+ *      ultra-wide is only exposed inside a multi-cam logical device —
+ *      vision-camera's single-lens filter mis-scored and fell back to
+ *      a plain wide-angle device.
+ *   2. flash threw `flash-not-available` on 0.5× because the standalone
+ *      ultra-wide device has no torch unit.
+ *
+ * Both stem from mounting ONE standalone physical device per lens.  The
+ * fix: prefer a MULTI-CAM device that carries the ultra-wide (so a
+ * single mounted device spans both FOVs via zoom AND carries the torch
+ * through its wide-angle member).  Fall back to standalone devices for
+ * phones — common on Android — where the ultra-wide has no multi-cam
+ * grouping, so we don't regress those.
+ *
+ * Pure + synchronous: takes a plain device list (the structural subset
+ * of vision-camera's `CameraDevice` we need) and returns the choice.
+ * No React, no vision-camera hooks — unit-tested directly.
+ */
+
+export type LensType = 'ultra-wide-angle-camera' | 'wide-angle-camera' | 'telephoto-camera';
+
+/**
+ * The structural subset of vision-camera's `CameraDevice` this selector
+ * reads.  Declared locally (not imported) so tests can build synthetic
+ * devices without the full vision-camera type, and so the SDK doesn't
+ * couple its selection logic to vision-camera's evolving shape.
+ */
+export interface DeviceLike {
+  id: string;
+  position: 'front' | 'back' | 'external';
+  physicalDevices: LensType[];
+  isMultiCam: boolean;
+  hasTorch: boolean;
+  minZoom: number;
+  neutralZoom: number;
+  maxZoom: number;
+}
+
+export type CaptureDeviceMode =
+  /** One multi-cam device spans wide + ultra-wide; switch lenses via zoom. */
+  | 'multicam'
+  /** Separate standalone wide + ultra-wide devices; switch by remounting. */
+  | 'standalone-uw'
+  /** No ultra-wide anywhere; wide-angle only (no 0.5× chip). */
+  | 'wide-only';
+
+export interface CaptureDeviceSelection<D extends DeviceLike = DeviceLike> {
+  /** The device to mount for the `1×` lens (and for `multicam`, all lenses). */
+  device: D | null;
+  /**
+   * The device to mount when the user picks `0.5×` in `standalone-uw`
+   * mode (a separate physical ultra-wide).  Null in `multicam` (same
+   * device, zoom instead) and `wide-only` (no ultra-wide).
+   */
+  ultraWideDevice: D | null;
+  mode: CaptureDeviceMode;
+  /** Whether a 0.5× chooser should be offered at all. */
+  has0_5x: boolean;
+  /** Whether the `1×`/primary mounted device can flash (drives flash UI). */
+  hasTorch: boolean;
+}
+
+const hasLens = (d: DeviceLike, lens: LensType) =>
+  d.physicalDevices.includes(lens);
+
+/**
+ * Choose the back-camera device(s) for capture.
+ *
+ * Priority:
+ *   1. multicam — a multi-cam device containing BOTH wide + ultra-wide
+ *      (best: one device, zoom-switch, torch via the wide member).
+ *   2. standalone-uw — a standalone wide AND a standalone ultra-wide
+ *      exist as separate devices (device-swap on lens change; flash
+ *      hidden on the torchless ultra-wide).
+ *   3. wide-only — no ultra-wide reachable; wide-angle only.
+ *
+ * @param devices  All enumerated camera devices (any position).
+ */
+export function selectCaptureDevice<D extends DeviceLike>(
+  devices: readonly D[],
+): CaptureDeviceSelection<D> {
+  const back = devices.filter((d) => d.position === 'back');
+
+  if (back.length === 0) {
+    return {
+      device: null,
+      ultraWideDevice: null,
+      mode: 'wide-only',
+      has0_5x: false,
+      hasTorch: false,
+    };
+  }
+
+  // ── 1. Prefer a multi-cam device that carries BOTH wide + ultra-wide.
+  // Among candidates, prefer the one that ALSO has a torch (so flash
+  // works on every lens), then the one spanning the widest zoom range
+  // (more lenses → more reach), as a stable tiebreak.
+  const multicamCandidates = back.filter(
+    (d) =>
+      d.isMultiCam &&
+      hasLens(d, 'wide-angle-camera') &&
+      hasLens(d, 'ultra-wide-angle-camera'),
+  );
+  if (multicamCandidates.length > 0) {
+    const device = multicamCandidates.reduce((best, d) => {
+      // torch-bearing wins; then wider zoom span; then more lenses.
+      if (d.hasTorch !== best.hasTorch) return d.hasTorch ? d : best;
+      const span = d.maxZoom - d.minZoom;
+      const bestSpan = best.maxZoom - best.minZoom;
+      if (span !== bestSpan) return span > bestSpan ? d : best;
+      return d.physicalDevices.length > best.physicalDevices.length ? d : best;
+    });
+    return {
+      device,
+      ultraWideDevice: null,
+      mode: 'multicam',
+      has0_5x: true,
+      hasTorch: device.hasTorch,
+    };
+  }
+
+  // ── 2. Standalone ultra-wide + standalone wide as separate devices.
+  // CRITICAL: this fallback is what keeps phones (esp. Android) where
+  // the ultra-wide has NO multi-cam grouping working — without it,
+  // restricting to multicam would REINTRODUCE the "0.5× shows wide" bug
+  // for that device population.
+  //
+  // Prefer a torch-bearing wide-angle device as the `1×`/primary mount.
+  const wideDevices = back.filter((d) => hasLens(d, 'wide-angle-camera'));
+  const ultraWide =
+    back.find((d) => !d.isMultiCam && hasLens(d, 'ultra-wide-angle-camera')) ??
+    back.find((d) => hasLens(d, 'ultra-wide-angle-camera')) ??
+    null;
+
+  if (wideDevices.length > 0 && ultraWide != null) {
+    // Prefer the simplest wide device (fewest extra lenses) with a torch
+    // as the 1× mount, so 1× flash works.  Falls back to any wide device.
+    const primary =
+      wideDevices.find((d) => d.hasTorch) ?? wideDevices[0];
+    return {
+      device: primary,
+      ultraWideDevice: ultraWide,
+      mode: 'standalone-uw',
+      has0_5x: true,
+      hasTorch: primary.hasTorch,
+    };
+  }
+
+  // ── 3. Wide-angle only (no ultra-wide reachable on this device).
+  const wideOnly =
+    wideDevices.find((d) => d.hasTorch) ?? wideDevices[0] ?? back[0];
+  return {
+    device: wideOnly,
+    ultraWideDevice: null,
+    mode: 'wide-only',
+    has0_5x: false,
+    hasTorch: wideOnly.hasTorch,
+  };
+}
+
+/**
+ * Map a UI lens label to a vision-camera `zoom` value for the
+ * `multicam` mode (where lens switching is zoom, not device swap).
+ *
+ * - `1×`   → the device's `neutralZoom` (wide-angle baseline; vision-
+ *   camera docs: "where the camera is in wide-angle mode and hasn't
+ *   switched to ultra-wide or telephoto yet").
+ * - `0.5×` → `minZoom` (the ultra-wide end of the zoom range).
+ *
+ * Returns `neutralZoom` for any non-0.5× label as a safe default.
+ * Only meaningful in `multicam` mode; the standalone path swaps devices
+ * and ignores this.
+ */
+export function zoomForLens(
+  device: Pick<DeviceLike, 'minZoom' | 'neutralZoom'>,
+  lens: '1x' | '0.5x',
+): number {
+  return lens === '0.5x' ? device.minZoom : device.neutralZoom;
+}

package/src/camera/useCapture.ts

@@ -36,6 +36,12 @@ import {
   type TakePhotoOptions,
 } from 'react-native-vision-camera';
 
+import {
+  selectCaptureDevice,
+  zoomForLens,
+  type CaptureDeviceMode,
+  type DeviceLike,
+} from './selectCaptureDevice';
 import { runQualityCheck } from '../quality/runQualityCheck';
 import { normaliseOrientation } from '../quality/normaliseOrientation';
 import { toBareFilePath } from '../utils/paths';
@@ -92,8 +98,22 @@ export interface UseCaptureOptions {
    * behaves as if `preferredPhysicalDevice` was undefined).  The
    * returned `availablePhysicalDevices` exposes what the device
    * actually offers so the host can render an appropriate switcher.
+   *
+   * v0.13.2 — superseded by `lens` for `<Camera>`'s own use (see
+   * `selectCaptureDevice`).  Still honoured for direct Layer-2 hosts.
    */
   preferredPhysicalDevice?: PhysicalCameraDeviceType;
+  /**
+   * v0.13.2 — the active UI lens (`1×` / `0.5×`).  When supplied, the
+   * hook uses capability-aware selection (`selectCaptureDevice`): it
+   * prefers a multi-cam device spanning both FOVs (lens switched via
+   * `zoom`, torch available on every lens), and falls back to a
+   * standalone ultra-wide device-swap only where no such multi-cam
+   * device exists.  Fixes the "0.5× shows wide-angle on some phones"
+   * and "flash unavailable on 0.5×" bugs.  When omitted, the legacy
+   * `preferredPhysicalDevice` path is used (backwards-compatible).
+   */
+  lens?: '1x' | '0.5x';
 }
 
 
@@ -166,6 +186,31 @@ export interface UseCaptureReturn {
    * load).  Always populated by the time the camera is mountable.
    */
   availablePhysicalDevices: PhysicalCameraDeviceType[];
+  /**
+   * v0.13.2 — how lenses are switched for the mounted device:
+   *   'multicam'      — one device spans both FOVs; switch via `deviceZoom`.
+   *   'standalone-uw' — separate ultra-wide device; switch by remounting.
+   *   'wide-only'     — no ultra-wide; no 0.5× chooser.
+   */
+  captureMode: CaptureDeviceMode;
+  /**
+   * v0.13.2 — whether the device can offer a 0.5× ultra-wide lens AT ALL
+   * (real capability, replacing the old hardcoded assumption).  Drives
+   * whether `<Camera>` renders the lens chooser.
+   */
+  has0_5x: boolean;
+  /**
+   * v0.13.2 — whether the currently-MOUNTED device has a torch.  Drives
+   * the flash control's availability (the standalone ultra-wide has none).
+   */
+  deviceHasTorch: boolean;
+  /**
+   * v0.13.2 — the `zoom` value to apply for the active lens in
+   * `multicam` mode (0.5× → ultra-wide end, 1× → wide baseline).
+   * `undefined` in standalone/wide-only modes (lens = device identity,
+   * no zoom needed).  Pass to `<CameraView zoom>`.
+   */
+  deviceZoom: number | undefined;
 }
 
 
@@ -208,22 +253,61 @@ export function useCapture(options: UseCaptureOptions = {}): UseCaptureReturn {
     qualityThresholds,
     takePhotoOptions,
     preferredPhysicalDevice,
+    lens,
   } = options;
 
   const cameraRef = useRef<Camera | null>(null);
 
-  // 2026-05-14 — physical-lens-aware device picker.
+  const allDevices = useCameraDevices();
+
+  // v0.13.2 — capability-aware selection (`lens` supplied) vs legacy
+  // per-lens physical-device swap (`preferredPhysicalDevice`).
   //
-  // When `preferredPhysicalDevice` is supplied, ask vision-camera
-  // for a device that exposes that specific physical lens (e.g.,
-  // 'ultra-wide-angle-camera').  Falls back to the position-default
-  // when the device doesn't have that lens.  When undefined, behaves
-  // identically to the pre-2026-05-14 useCameraDevice(position) call.
-  const deviceWithPreferred = useCameraDevice(cameraPosition, {
+  // Capability-aware: `selectCaptureDevice` prefers a multi-cam device
+  // that spans wide + ultra-wide (so 0.5× is reached via `zoom` and the
+  // torch works on every lens), falling back to a standalone ultra-wide
+  // device-swap only where the platform has no such multi-cam grouping.
+  // This fixes (a) 0.5× silently showing the wide-angle FOV on phones
+  // where the ultra-wide is only inside a multi-cam device, and (b)
+  // flash being unavailable on the torchless standalone ultra-wide.
+  const selection = useMemo(
+    () => selectCaptureDevice(allDevices as unknown as DeviceLike[]),
+    [allDevices],
+  );
+
+
+  // Legacy path (no `lens`): preserve the pre-v0.13.2 per-physical-lens
+  // request so direct Layer-2 hosts that pass `preferredPhysicalDevice`
+  // are unaffected.
+  const legacyDevice = useCameraDevice(cameraPosition, {
     physicalDevices: preferredPhysicalDevice ? [preferredPhysicalDevice] : undefined,
   });
-  const deviceFallback = useCameraDevice(cameraPosition);
-  const device = deviceWithPreferred ?? deviceFallback;
+  const legacyFallback = useCameraDevice(cameraPosition);
+
+  // The mounted device:
+  //   - lens supplied + multicam     → the single multi-cam device
+  //     (lens switched via `zoom`, computed below).
+  //   - lens supplied + standalone-uw→ swap to the ultra-wide device on
+  //     0.5×, else the wide primary (matches the legacy swap, but with
+  //     correct device identity from `selectCaptureDevice`).
+  //   - lens supplied + wide-only    → the wide device (0.5× hidden).
+  //   - no lens                      → legacy behaviour.
+  let device: ReturnType<typeof useCameraDevice>;
+  let activeZoom: number | undefined;
+  if (lens != null) {
+    if (selection.mode === 'standalone-uw' && lens === '0.5x') {
+      device = (selection.ultraWideDevice as typeof legacyDevice) ?? selection.device as typeof legacyDevice ?? legacyFallback;
+    } else {
+      device = (selection.device as typeof legacyDevice) ?? legacyFallback;
+    }
+    activeZoom =
+      selection.mode === 'multicam' && selection.device
+        ? zoomForLens(selection.device, lens)
+        : undefined;
+  } else {
+    device = legacyDevice ?? legacyFallback;
+    activeZoom = undefined;
+  }
 
   // Enumerate ALL physical lens types available on the chosen
   // position so the host can decide whether to render a switcher.
@@ -231,8 +315,8 @@ export function useCapture(options: UseCaptureOptions = {}): UseCaptureReturn {
   // has `physicalDevices: PhysicalCameraDeviceType[]`.  We dedupe the
   // union across all devices at `position` so the host sees the full
   // set the platform exposes (some phones expose ultra-wide only via
-  // a separate logical camera, not the main one).
-  const allDevices = useCameraDevices();
+  // a separate logical camera, not the main one).  `allDevices` is
+  // computed once above (shared with `selectCaptureDevice`).
   const availablePhysicalDevices = useMemo<PhysicalCameraDeviceType[]>(() => {
     const seen = new Set<PhysicalCameraDeviceType>();
     for (const d of allDevices) {
@@ -334,5 +418,9 @@ export function useCapture(options: UseCaptureOptions = {}): UseCaptureReturn {
     isCapturing,
     takePhoto,
     availablePhysicalDevices,
+    captureMode: selection.mode,
+    has0_5x: selection.has0_5x,
+    deviceHasTorch: device?.hasTorch ?? false,
+    deviceZoom: activeZoom,
   };
 }