react-native-image-stitcher 0.1.0

package/dist/camera/Camera.js

@@ -0,0 +1,688 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Camera — the public, props-based camera component for the
+ * `react-native-image-stitcher` library (publication target per the
+ * 2026-05-15 design doc).
+ *
+ * One component, both modes:
+ *   - **Tap shutter** → single photo via vision-camera's takePhoto
+ *     (non-AR) or ARFrame.capturedImage (AR).
+ *   - **Hold shutter** → panorama capture; pan-and-release produces
+ *     a stitched panorama JPEG via the incremental stitcher.
+ *
+ * One component, both capture sources:
+ *   - **AR mode** (ARKit / ARCore) — used for pose-aware stitching
+ *     when the device supports it.
+ *   - **Non-AR mode** (vision-camera + IMU) — fallback path,
+ *     forced when the 0.5× ultra-wide lens is selected (AR sessions
+ *     are tied to a single physical lens; can't switch mid-session).
+ *
+ * The Camera component owns its runtime state (arPreference, lens,
+ * settings).  Parent props are read as INITIAL VALUES at mount; the
+ * parent listens for state changes via the callback props.  This
+ * "uncontrolled" model matches React's `<input>` convention and
+ * matches the design doc's intent (NF — component owns runtime state,
+ * parent persists via callbacks if desired).
+ *
+ * Scope note (step 2 of the SDK extract plan):
+ *   - Props-driven API for both photo + panorama modes — DONE here.
+ *   - Lens chip + AR toggle UI (U1) — DONE here.
+ *   - `showSettingsButton` gates the existing PanoramaSettingsModal — DONE.
+ *   - Imperative ref methods (`takePhoto()`, `startPanorama()`,
+ *     `stopPanorama()`) — deferred; the built-in shutter button is the
+ *     primary affordance for v0.1.0.
+ *   - Forward-looking props (`defaultCompositingResolMP`,
+ *     `defaultRegistrationResolMP`, `defaultSeamEstimationResolMP`)
+ *     are accepted but currently no-ops — those fields don't exist on
+ *     PanoramaSettings yet.  They're declared so the public API is
+ *     stable before they wire through; the wiring is a follow-up.
+ *
+ * See: docs/site-content/design/2026-05-15-react-native-image-stitcher-publication.md
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraError = void 0;
+exports.Camera = Camera;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const react_native_safe_area_context_1 = require("react-native-safe-area-context");
+const useARSession_1 = require("../ar/useARSession");
+const ARCameraView_1 = require("./ARCameraView");
+const CameraShutter_1 = require("./CameraShutter");
+const CameraView_1 = require("./CameraView");
+const CaptureStatusOverlay_1 = require("./CaptureStatusOverlay");
+const PanoramaBandOverlay_1 = require("./PanoramaBandOverlay");
+const PanoramaSettingsModal_1 = require("./PanoramaSettingsModal");
+const useCapture_1 = require("./useCapture");
+const useDeviceOrientation_1 = require("./useDeviceOrientation");
+const incremental_1 = require("../stitching/incremental");
+const useIncrementalJSDriver_1 = require("../stitching/useIncrementalJSDriver");
+const useIncrementalStitcher_1 = require("../stitching/useIncrementalStitcher");
+const useIMUTranslationGate_1 = require("../sensors/useIMUTranslationGate");
+class CameraError extends Error {
+    constructor(code, message, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = 'CameraError';
+    }
+}
+exports.CameraError = CameraError;
+function LensChip({ lens, onChange, has0_5x }) {
+    if (!has0_5x) {
+        return (react_1.default.createElement(react_native_1.View, { style: [lensChipStyles.container, lensChipStyles.singleLens] },
+            react_1.default.createElement(react_native_1.Text, { style: lensChipStyles.label }, "1\u00D7")));
+    }
+    return (react_1.default.createElement(react_native_1.View, { style: lensChipStyles.container },
+        react_1.default.createElement(react_native_1.Pressable, { onPress: () => onChange('0.5x'), accessibilityRole: "button", accessibilityLabel: "0.5x ultra-wide lens", accessibilityState: { selected: lens === '0.5x' }, style: [
+                lensChipStyles.pill,
+                lens === '0.5x' && lensChipStyles.pillActive,
+            ] },
+            react_1.default.createElement(react_native_1.Text, { style: [
+                    lensChipStyles.label,
+                    lens === '0.5x' && lensChipStyles.labelActive,
+                ] }, "0.5\u00D7")),
+        react_1.default.createElement(react_native_1.Pressable, { onPress: () => onChange('1x'), accessibilityRole: "button", accessibilityLabel: "1x wide-angle lens", accessibilityState: { selected: lens === '1x' }, style: [
+                lensChipStyles.pill,
+                lens === '1x' && lensChipStyles.pillActive,
+            ] },
+            react_1.default.createElement(react_native_1.Text, { style: [
+                    lensChipStyles.label,
+                    lens === '1x' && lensChipStyles.labelActive,
+                ] }, "1\u00D7"))));
+}
+const lensChipStyles = react_native_1.StyleSheet.create({
+    container: {
+        flexDirection: 'row',
+        backgroundColor: 'rgba(0,0,0,0.45)',
+        borderRadius: 18,
+        padding: 3,
+        alignSelf: 'center',
+    },
+    singleLens: {
+        paddingHorizontal: 12,
+    },
+    pill: {
+        paddingHorizontal: 12,
+        paddingVertical: 6,
+        borderRadius: 14,
+        minWidth: 44,
+        alignItems: 'center',
+    },
+    pillActive: {
+        backgroundColor: '#ffd34d',
+    },
+    label: {
+        color: '#ffffff',
+        fontSize: 13,
+        fontWeight: '600',
+    },
+    labelActive: {
+        color: '#1a1a1a',
+    },
+});
+function ARToggle({ arEnabled, onToggle }) {
+    return (react_1.default.createElement(react_native_1.Pressable, { onPress: onToggle, accessibilityRole: "switch", accessibilityLabel: `AR mode ${arEnabled ? 'on' : 'off'}`, accessibilityState: { checked: arEnabled }, style: [arToggleStyles.container, arEnabled && arToggleStyles.containerOn] },
+        react_1.default.createElement(react_native_1.Text, { style: [
+                arToggleStyles.label,
+                arEnabled && arToggleStyles.labelOn,
+            ] }, "AR")));
+}
+const arToggleStyles = react_native_1.StyleSheet.create({
+    container: {
+        paddingHorizontal: 14,
+        paddingVertical: 8,
+        borderRadius: 16,
+        backgroundColor: 'rgba(0,0,0,0.45)',
+        minWidth: 56,
+        alignItems: 'center',
+    },
+    containerOn: {
+        backgroundColor: '#ffd34d',
+    },
+    label: {
+        color: '#ffffff',
+        fontSize: 13,
+        fontWeight: '700',
+        letterSpacing: 1,
+    },
+    labelOn: {
+        color: '#1a1a1a',
+    },
+});
+function SettingsButton({ onPress, topInset }) {
+    return (react_1.default.createElement(react_native_1.Pressable, { onPress: onPress, accessibilityRole: "button", accessibilityLabel: "Open camera settings", style: [settingsButtonStyles.container, { top: topInset + 8 }] },
+        react_1.default.createElement(react_native_1.Text, { style: settingsButtonStyles.glyph }, "\u2699")));
+}
+const settingsButtonStyles = react_native_1.StyleSheet.create({
+    container: {
+        position: 'absolute',
+        right: 14,
+        width: 40,
+        height: 40,
+        borderRadius: 20,
+        backgroundColor: 'rgba(0,0,0,0.45)',
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    glyph: {
+        color: '#ffffff',
+        fontSize: 22,
+        lineHeight: 24,
+    },
+});
+// ─── Main component ─────────────────────────────────────────────────
+/**
+ * Effective capture source derived from arPreference + lens + the
+ * device's AR support.  On a device without ARKit / ARCore, AR mode
+ * is unavailable regardless of the user's preference, and the AR
+ * toggle is hidden in the UI (see the bottom-bar JSX).  Selecting
+ * the 0.5x lens also forces non-AR because ARKit / ARCore sessions
+ * don't expose the ultra-wide camera.
+ */
+function deriveEffectiveCaptureSource(arPreference, lens, isARSupportedOnDevice) {
+    if (!isARSupportedOnDevice)
+        return 'non-ar';
+    if (lens === '0.5x')
+        return 'non-ar';
+    return arPreference ? 'ar' : 'non-ar';
+}
+/**
+ * Apply per-prop defaults to build the initial settings snapshot.
+ * The settings live in component state from there; the prop values
+ * never re-flow.
+ *
+ * Note: the `default*ResolMP` props don't have a home on PanoramaSettings
+ * yet — they're accepted on the prop interface for forward compatibility
+ * but ignored here.  Wiring is a follow-up once PanoramaSettings is
+ * extended.
+ */
+function buildInitialSettings(props) {
+    return {
+        ...PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS,
+        stitchMode: props.defaultStitchMode ?? PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.stitchMode,
+        blenderType: props.defaultBlender ?? PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.blenderType,
+        seamFinderType: props.defaultSeamFinder ?? PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.seamFinderType,
+        warperType: props.defaultWarper ?? PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.warperType,
+        flowNoveltyPercentile: props.defaultFlowNoveltyPercentile ??
+            PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.flowNoveltyPercentile,
+        flowEvalEveryNFrames: props.defaultFlowEvalEveryNFrames ??
+            PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.flowEvalEveryNFrames,
+        flowMaxTranslationCm: props.defaultFlowMaxTranslationCm ??
+            PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.flowMaxTranslationCm,
+        keyframeMaxCount: props.defaultKeyframeMaxCount ??
+            PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.keyframeMaxCount,
+        keyframeOverlapThreshold: props.defaultKeyframeOverlapThreshold ??
+            PanoramaSettingsModal_1.DEFAULT_PANORAMA_SETTINGS.keyframeOverlapThreshold,
+    };
+}
+/**
+ * Normalise a native-side file path into the `file://...` URI form
+ * that React Native's `<Image>` requires on Android.  iOS is lenient,
+ * but Android rejects bare `/data/...` paths and renders a blank
+ * Image with no error in the JS layer.
+ *
+ * Native code in this lib emits paths in two flavours:
+ *   - useCapture.compressedUri already includes `file://` (it's
+ *     normalised in `makeCaptureResult`).
+ *   - ARCameraView.takePhoto, IncrementalStitcher.finalize, and the
+ *     `batchKeyframeThumbnailPath` from `IncrementalStateUpdate` all
+ *     return bare paths.  Those are the cases this helper handles.
+ *
+ * Already-prefixed inputs are passed through unchanged, so it's safe
+ * to call defensively at every public-API boundary.
+ */
+function ensureFileUri(path) {
+    if (!path)
+        return '';
+    if (path.startsWith('file://') || path.startsWith('content://') || path.startsWith('http')) {
+        return path;
+    }
+    return `file://${path}`;
+}
+/**
+ * The public `<Camera>` component.
+ */
+function Camera(props) {
+    const { defaultCaptureSource = 'ar', defaultLens = '1x', enablePhotoMode = true, enablePanoramaMode = true, showSettingsButton = false, style, onCapture, onCaptureSourceChange, onLensChange, onFramesDropped, onError, } = props;
+    const insets = (0, react_native_safe_area_context_1.useSafeAreaInsets)();
+    // ── State ───────────────────────────────────────────────────────
+    const [arPreference, setArPreference] = (0, react_1.useState)(defaultCaptureSource === 'ar');
+    const [lens, setLens] = (0, react_1.useState)(defaultLens);
+    const [settings, setSettings] = (0, react_1.useState)(() => buildInitialSettings(props));
+    const [settingsModalVisible, setSettingsModalVisible] = (0, react_1.useState)(false);
+    const [statusPhase, setStatusPhase] = (0, react_1.useState)('idle');
+    const [recordingStartedAt, setRecordingStartedAt] = (0, react_1.useState)(null);
+    const [incrementalState, setIncrementalState] = (0, react_1.useState)(null);
+    const [batchKeyframeThumbnails, setBatchKeyframeThumbnails] = (0, react_1.useState)([]);
+    const [cameraTransitioning, setCameraTransitioning] = (0, react_1.useState)(false);
+    // ARKit / ARCore device-support probe.  `isAvailable` is `false`
+    // initially and becomes `true` after the native isSupported() check
+    // resolves (~50-200 ms after mount).  Devices without ARKit / ARCore
+    // (older iPhones, ARCore-less Androids, simulators) stay `false`
+    // forever, which forces non-AR capture everywhere and hides the
+    // AR toggle in the bottom bar (see JSX below).
+    const { isAvailable: isARSupportedOnDevice } = (0, useARSession_1.useARSession)();
+    const effectiveCaptureSource = deriveEffectiveCaptureSource(arPreference, lens, isARSupportedOnDevice);
+    const isAR = effectiveCaptureSource === 'ar';
+    const isNonAR = !isAR;
+    const deviceOrientation = (0, useDeviceOrientation_1.useDeviceOrientation)();
+    // ── Camera handoff gate ─────────────────────────────────────────
+    //
+    // The placeholder rendered while the underlying camera identity
+    // changes (AR toggle, lens swap).  Without this gap, Android
+    // vision-camera v4 races the new session's open against the old
+    // session's teardown → "Session has been closed"
+    // IllegalStateException OR "Maximum cameras in use"
+    // CameraAccessException.
+    //
+    // CRITICAL: A naive useState + useEffect approach DOESN'T WORK.
+    // useEffect runs AFTER the commit phase — so on the render where
+    // isAR/lens flips, the effect hasn't yet set the gate flag, the
+    // render branch already evaluated `flag ? placeholder : camera`
+    // against the STALE flag=false → the new camera mounts in that
+    // commit → race → crash.
+    //
+    // Fix (mirrors AuditCaptureScreen.tsx ~L695-766): track the
+    // "last fully settled" identity in refs and compare them
+    // SYNCHRONOUSLY during render.  The gate closes on the FIRST
+    // render where isAR/lens differs from the settled refs.  The
+    // useEffect below does the async work (explicit AR session stop +
+    // 250 ms grace) and then updates the refs + clears the flag
+    // together to drop the gate.
+    const settledIsARRef = (0, react_1.useRef)(isAR);
+    const settledLensRef = (0, react_1.useRef)(lens);
+    const inFlightTransition = settledIsARRef.current !== isAR
+        || settledLensRef.current !== lens
+        || cameraTransitioning;
+    // ── Notify parent of capture-source changes ─────────────────────
+    const lastEmittedSourceRef = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        if (lastEmittedSourceRef.current !== effectiveCaptureSource) {
+            lastEmittedSourceRef.current = effectiveCaptureSource;
+            onCaptureSourceChange?.(effectiveCaptureSource);
+        }
+    }, [effectiveCaptureSource, onCaptureSourceChange]);
+    // ── Lens chip availability ──────────────────────────────────────
+    // TODO follow-up: probe the device's available physical lenses via
+    // vision-camera's `useCameraDevices` and surface in
+    // `useCapture().availablePhysicalDevices`.  For now we assume the
+    // 0.5x ultra-wide exists on modern devices.  When it doesn't, the
+    // lens chip degenerates to a static 1× indicator (see LensChip).
+    const has0_5x = true;
+    // ── Capture hooks ───────────────────────────────────────────────
+    const capture = (0, useCapture_1.useCapture)({
+        cameraPosition: 'back',
+        enableQualityChecks: false,
+        preferredPhysicalDevice: lens === '0.5x' ? 'ultra-wide-angle-camera' : 'wide-angle-camera',
+    });
+    const incremental = (0, useIncrementalStitcher_1.useIncrementalStitcher)();
+    const visionCameraRef = (0, react_1.useRef)(null);
+    const arViewRef = (0, react_1.useRef)(null);
+    // Effect that does the async transition work whenever the settled
+    // refs disagree with the current isAR/lens.  Order matters:
+    //   1. Set the cameraTransitioning state so the gate stays closed
+    //      after the synchronous compare flips back to "settled" once
+    //      we update the refs.
+    //   2. Explicitly stop the AR session if we were in AR mode — this
+    //      releases ARCore's grip on Camera2 BEFORE vision-camera tries
+    //      to open it.  Without this on Android the next openCamera()
+    //      call hits "Maximum cameras in use".  The promise is ignored
+    //      if RNSARSession.stop fails or isn't available.
+    //   3. Wait 250 ms (Camera2's HAL onClosed is async; this gives it
+    //      time to fully release the handle).
+    //   4. Update settled refs + clear cameraTransitioning together so
+    //      the gate opens on the same commit.
+    (0, react_1.useEffect)(() => {
+        if (settledIsARRef.current === isAR && settledLensRef.current === lens) {
+            return undefined;
+        }
+        setCameraTransitioning(true);
+        let cancelled = false;
+        const finishTransition = () => {
+            if (cancelled)
+                return;
+            settledIsARRef.current = isAR;
+            settledLensRef.current = lens;
+            setCameraTransitioning(false);
+        };
+        const wasAR = settledIsARRef.current;
+        const arModule = react_native_1.NativeModules.RNSARSession;
+        const stopPromise = wasAR && arModule?.stop ? arModule.stop() : Promise.resolve();
+        stopPromise
+            .catch(() => undefined)
+            .then(() => {
+            setTimeout(finishTransition, 250);
+        });
+        return () => { cancelled = true; };
+    }, [isAR, lens]);
+    // IMU translation gate — only in non-AR mode.
+    const imuGate = (0, useIMUTranslationGate_1.useIMUTranslationGate)({
+        enabled: isNonAR
+            && statusPhase === 'recording'
+            && settings.flowMaxTranslationCm > 0,
+        budgetMeters: Math.max(0.001, settings.flowMaxTranslationCm / 100.0),
+        onBudgetExceeded: () => {
+            const mod = (0, incremental_1.getIncrementalNativeModule)();
+            mod?.markNextFrameAsLastKeyframe?.().catch(() => undefined);
+        },
+    });
+    // JS-driver for non-AR captures (iOS + Android).  In AR mode the
+    // engine consumes frames from the ARSession stream natively, so this
+    // hook stays idle.
+    //
+    // IMPORTANT: start()/stop() are called imperatively from the hold
+    // handlers below — NOT from a useEffect driven by statusPhase.  The
+    // hook returns a fresh object identity on every render, and during
+    // a recording the engine emits IncrementalStateUpdate events that
+    // cause re-renders multiple times per second.  An effect with
+    // `jsDriver` in its deps would teardown + restart the driver on
+    // every event, resetting the gyro accumulator (yaw/pitch) to zero
+    // each cycle and nulling the cameraRef during the brief gap.  The
+    // user-visible symptom was "only the first keyframe is accepted,
+    // every subsequent snapshot sees pose=(0,0) and is rejected as a
+    // duplicate of the first".  Matching AuditCaptureScreen's proven
+    // imperative pattern (start on hold-start, stop on hold-end) avoids
+    // the re-render churn entirely.
+    const jsDriver = (0, useIncrementalJSDriver_1.useIncrementalJSDriver)();
+    // Safety: ensure the driver is stopped if the component unmounts
+    // mid-recording.  Empty deps so this only fires on unmount.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    (0, react_1.useEffect)(() => () => { jsDriver.stop(); }, []);
+    // ── Subscribe to engine state for live keyframe thumbs ──────────
+    (0, react_1.useEffect)(() => {
+        const sub = (0, incremental_1.subscribeIncrementalState)((state) => {
+            setIncrementalState(state);
+            if (state?.batchKeyframeThumbnailPath) {
+                setBatchKeyframeThumbnails((prev) => {
+                    // De-dupe — same path may emit on subsequent ticks.
+                    // Normalise to `file://...` so Android <Image> in the band
+                    // overlay can actually render the thumbnail.
+                    const path = ensureFileUri(state.batchKeyframeThumbnailPath);
+                    if (prev.includes(path))
+                        return prev;
+                    return [...prev, path];
+                });
+            }
+        });
+        return () => { sub?.remove?.(); };
+    }, []);
+    (0, react_1.useEffect)(() => {
+        if (statusPhase === 'recording') {
+            setBatchKeyframeThumbnails([]);
+            setIncrementalState(null);
+        }
+    }, [statusPhase]);
+    // ── Shutter handlers ────────────────────────────────────────────
+    const handleTap = (0, react_1.useCallback)(async () => {
+        if (!enablePhotoMode)
+            return;
+        try {
+            let uri;
+            let width;
+            let height;
+            if (isAR && arViewRef.current) {
+                const photo = await arViewRef.current.takePhoto({ quality: 90 });
+                // Native side returns a bare `/data/.../foo.jpg` path.  Android
+                // <Image> needs the `file://` scheme to render it; iOS is OK
+                // either way.
+                uri = ensureFileUri(photo.path);
+                width = photo.width;
+                height = photo.height;
+            }
+            else {
+                if (!visionCameraRef.current) {
+                    throw new CameraError('CAMERA_DEVICE_UNAVAILABLE', 'vision-camera ref is not attached');
+                }
+                // useCapture.takePhoto wraps the cameraRef internally;
+                // attach via assignment so the hook's ref points at our
+                // local ref.  This works because RefObject is just { current }.
+                // Effect: capture.takePhoto() resolves with the SDK's
+                // CaptureResult (with compressedUri / width / height).
+                // We adapt to the public CameraCaptureResult shape.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                capture.cameraRef.current = visionCameraRef.current;
+                const result = await capture.takePhoto();
+                uri = result.compressedUri;
+                width = result.width;
+                height = result.height;
+            }
+            onCapture?.({ type: 'photo', uri, width, height });
+        }
+        catch (err) {
+            const e = err instanceof CameraError
+                ? err
+                : new CameraError('PHOTO_CAPTURE_FAILED', err instanceof Error ? err.message : String(err), err);
+            onError?.(e);
+        }
+    }, [enablePhotoMode, isAR, capture, onCapture, onError]);
+    const handleHoldStart = (0, react_1.useCallback)(async () => {
+        if (!enablePanoramaMode)
+            return;
+        if (!(0, incremental_1.incrementalStitcherIsAvailable)()) {
+            onError?.(new CameraError('PANORAMA_START_FAILED', 'Native incremental stitcher module not available'));
+            return;
+        }
+        try {
+            setStatusPhase('recording');
+            setRecordingStartedAt(Date.now());
+            const orientationRotation = deviceOrientation === 'portrait' ? 90
+                : deviceOrientation === 'portrait-upside-down' ? 270
+                    : 0;
+            await incremental.start({
+                snapshotJpegQuality: 75,
+                snapshotEveryNAccepts: 1,
+                frameRotationDegrees: orientationRotation,
+                captureOrientation: deviceOrientation,
+                frameSourceMode: isNonAR ? 'jsDriver' : 'arSession',
+                composeWidth: 1920,
+                composeHeight: 1080,
+                canvasWidth: 5000,
+                canvasHeight: 5000,
+                engine: 'batch-keyframe',
+                config: {
+                    stitchMode: settings.stitchMode,
+                    warperType: settings.warperType,
+                    blenderType: settings.blenderType,
+                    seamFinderType: settings.seamFinderType,
+                    flowNoveltyPercentile: settings.flowNoveltyPercentile,
+                    flowEvalEveryNFrames: settings.flowEvalEveryNFrames,
+                    flowMaxTranslationCm: settings.flowMaxTranslationCm,
+                    keyframeMaxCount: settings.keyframeMaxCount,
+                    keyframeOverlapThreshold: settings.keyframeOverlapThreshold,
+                    frameSelectionMode: 'flow-based',
+                },
+            });
+            imuGate.resetAnchor();
+            // Start pumping vision-camera snapshots into the engine for
+            // non-AR captures.  AR mode feeds frames natively from the
+            // ARSession, so the JS driver stays idle in that path.  This
+            // mirrors AuditCaptureScreen.handleHoldStart's `androidDriver.start`
+            // imperative call — see the comment near `useIncrementalJSDriver`
+            // for why this is NOT done via useEffect.
+            if (isNonAR) {
+                jsDriver.start(visionCameraRef);
+            }
+        }
+        catch (err) {
+            setStatusPhase('idle');
+            onError?.(new CameraError('PANORAMA_START_FAILED', err instanceof Error ? err.message : String(err), err));
+        }
+    }, [
+        enablePanoramaMode,
+        incremental,
+        isNonAR,
+        deviceOrientation,
+        settings,
+        imuGate,
+        jsDriver,
+        onError,
+    ]);
+    const handleHoldEnd = (0, react_1.useCallback)(async () => {
+        if (statusPhase !== 'recording')
+            return;
+        setStatusPhase('stitching');
+        // Stop pumping new snapshots before finalizing so the engine isn't
+        // racing the final cv::Stitcher pass against late-arriving keyframes.
+        // No-op in AR mode where jsDriver was never started.
+        jsDriver.stop();
+        try {
+            const result = await incremental.finalize(undefined, 90, deviceOrientation);
+            if (typeof result.framesRequested === 'number'
+                && typeof result.framesIncluded === 'number'
+                && result.framesIncluded < result.framesRequested) {
+                onFramesDropped?.({
+                    requested: result.framesRequested,
+                    included: result.framesIncluded,
+                });
+            }
+            onCapture?.({
+                type: 'panorama',
+                // Native finalize() returns a bare `/data/.../foo.jpg` path;
+                // normalise to `file://` for Android <Image>.
+                uri: ensureFileUri(result.panoramaPath),
+                width: result.width,
+                height: result.height,
+                framesRequested: result.framesRequested ?? -1,
+                framesIncluded: result.framesIncluded ?? -1,
+                framesDropped: (result.framesRequested ?? 0) - (result.framesIncluded ?? 0),
+                finalConfidenceThresh: result.finalConfidenceThresh ?? -1,
+                durationMs: Date.now() - (recordingStartedAt ?? Date.now()),
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const code = /need more images/i.test(message) ? 'STITCH_NEED_MORE_IMGS'
+                : /homography/i.test(message) ? 'STITCH_HOMOGRAPHY_FAIL'
+                    : /camera params/i.test(message) ? 'STITCH_CAMERA_PARAMS_FAIL'
+                        : /out of memory|oom/i.test(message) ? 'STITCH_OOM'
+                            : 'PANORAMA_FINALIZE_FAILED';
+            onError?.(new CameraError(code, message, err));
+        }
+        finally {
+            setStatusPhase('idle');
+            setRecordingStartedAt(null);
+        }
+    }, [
+        statusPhase,
+        incremental,
+        deviceOrientation,
+        onCapture,
+        onFramesDropped,
+        onError,
+        recordingStartedAt,
+        jsDriver,
+    ]);
+    // ── Lens / AR-toggle handlers ───────────────────────────────────
+    const handleLensChange = (0, react_1.useCallback)((next) => {
+        setLens(next);
+        onLensChange?.(next);
+    }, [onLensChange]);
+    const handleARToggle = (0, react_1.useCallback)(() => {
+        setArPreference((prev) => !prev);
+    }, []);
+    // ── JSX ─────────────────────────────────────────────────────────
+    return (react_1.default.createElement(react_native_1.View, { style: [styles.container, style] },
+        inFlightTransition ? (react_1.default.createElement(react_native_1.View, { style: [react_native_1.StyleSheet.absoluteFill, styles.transitionPlaceholder] },
+            react_1.default.createElement(react_native_1.Text, { style: styles.transitionLabel }, "Switching camera\u2026"))) : isAR ? (react_1.default.createElement(ARCameraView_1.ARCameraView, { ref: arViewRef, style: react_native_1.StyleSheet.absoluteFill })) : (react_1.default.createElement(CameraView_1.CameraView, { ref: visionCameraRef, device: capture.device, isActive: true, 
+            // `video={true}` is REQUIRED for takeSnapshot to work on iOS.
+            // vision-camera v4's iOS implementation of takeSnapshot waits
+            // for a frame on the video pipeline; with video disabled, the
+            // promise never resolves and the JS frame-driver stalls after
+            // the very first buffered preview frame.  Android takeSnapshot
+            // works either way.  Pattern matches AuditCaptureScreen.tsx
+            // which has run on `video` (true) for months without issue.
+            video: true, flash: "off", style: react_native_1.StyleSheet.absoluteFill })),
+        react_1.default.createElement(CaptureStatusOverlay_1.CaptureStatusOverlay, { phase: statusPhase, topInset: insets.top, recordingStartedAt: recordingStartedAt ?? undefined }),
+        showSettingsButton && (react_1.default.createElement(SettingsButton, { topInset: insets.top, onPress: () => setSettingsModalVisible(true) })),
+        react_1.default.createElement(react_native_1.View, { pointerEvents: "box-none", style: [styles.bottomArea, { paddingBottom: insets.bottom + 12 }] },
+            statusPhase === 'recording' && (react_1.default.createElement(PanoramaBandOverlay_1.PanoramaBandOverlay, { state: incrementalState, frameUris: batchKeyframeThumbnails, captureOrientation: deviceOrientation })),
+            react_1.default.createElement(react_native_1.View, { style: styles.bottomBar },
+                react_1.default.createElement(react_native_1.View, { style: styles.bottomBarLeft }),
+                react_1.default.createElement(react_native_1.View, { style: styles.bottomBarCenter },
+                    react_1.default.createElement(LensChip, { lens: lens, onChange: handleLensChange, has0_5x: has0_5x }),
+                    react_1.default.createElement(react_native_1.View, { style: styles.shutterWrap },
+                        react_1.default.createElement(CameraShutter_1.CameraShutter, { onTap: handleTap, onHoldStart: enablePanoramaMode ? handleHoldStart : noop, onHoldComplete: enablePanoramaMode ? handleHoldEnd : noop, isProcessing: statusPhase === 'stitching', disabled: statusPhase === 'stitching' }))),
+                react_1.default.createElement(react_native_1.View, { style: styles.bottomBarRight }, lens === '1x' && isARSupportedOnDevice && (react_1.default.createElement(ARToggle, { arEnabled: arPreference, onToggle: handleARToggle }))))),
+        react_1.default.createElement(PanoramaSettingsModal_1.PanoramaSettingsModal, { visible: settingsModalVisible, settings: settings, onChange: setSettings, onClose: () => setSettingsModalVisible(false) })));
+}
+function noop() {
+    /* no-op handler used when panorama mode is disabled */
+}
+const styles = react_native_1.StyleSheet.create({
+    container: {
+        flex: 1,
+        backgroundColor: '#000',
+    },
+    transitionPlaceholder: {
+        backgroundColor: '#000',
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    transitionLabel: {
+        color: 'rgba(255,255,255,0.6)',
+        fontSize: 13,
+    },
+    bottomArea: {
+        position: 'absolute',
+        left: 0,
+        right: 0,
+        bottom: 0,
+        flexDirection: 'column',
+        alignItems: 'stretch',
+    },
+    bottomBar: {
+        flexDirection: 'row',
+        paddingHorizontal: 18,
+        alignItems: 'flex-end',
+    },
+    bottomBarLeft: {
+        flex: 1,
+    },
+    bottomBarCenter: {
+        flex: 1,
+        alignItems: 'center',
+    },
+    bottomBarRight: {
+        flex: 1,
+        alignItems: 'flex-end',
+        justifyContent: 'flex-end',
+    },
+    shutterWrap: {
+        marginTop: 12,
+    },
+});
+//# sourceMappingURL=Camera.js.map