react-native-image-stitcher 0.2.1 → 0.4.0

package/dist/camera/PanoramaSettingsModal.js

@@ -1,21 +1,57 @@
 "use strict";
 // SPDX-License-Identifier: Apache-2.0
 /**
- * PanoramaSettingsModal — runtime A/B testing surface for the
- * stitcher pipeline.  Operators in the field can toggle warper,
- * blender, and tuning constants between captures to see what
- * looks best on real shelf scenes.
+ * PanoramaSettingsModal — runtime tuning surface for <Camera>'s
+ * batch-keyframe panorama capture.
  *
- * The modal is presentational: the host owns the settings state
- * (typically `useState<PanoramaSettings>`) and renders the modal
- * with `visible` toggled by a gear-icon press in the capture
- * header.  Settings flow OUT via `onChange` for each tweak.
+ * v0.4 rewrite (Phase 2 of F10):
+ * ──────────────────────────────
  *
- * Why expose this as an SDK component instead of leaving it to
- * each host?  The set of tunable knobs IS the SDK's contract —
- * if a new setting is added (e.g. registration MP) the SDK ships
- * the UI for it in lockstep with the param itself, instead of
- * forcing every host app to update its settings screen.
+ * The v0.3 modal exposed a flat 45-field surface that mixed
+ * batch-keyframe knobs with slit-scan, hybrid, and video-recording
+ * fallback fields the engine never reads in <Camera>'s
+ * `engine: 'batch-keyframe'` path.  The 2026-05-22 audit (v0.3.0
+ * CHANGELOG) traced every field's native consumer and proved most of
+ * the cross-engine fields were dead surface in this modal.
+ *
+ * v0.4 narrows the modal to exactly the surface <Camera> consumes:
+ * the `PanoramaSettings` type defined in `./PanoramaSettings.ts`.  Each
+ * section in the modal mirrors a sub-tree of that type — operators see
+ * the same shape in the UI as the code, and host apps that want to
+ * tune slit-scan or hybrid engines build their own analogous
+ * SlitscanSettingsModal / HybridSettingsModal on top of those types.
+ *
+ * UI structure (matches the type tree):
+ *
+ *   - Debug                       (top-level, `debug`)
+ *   - Frame selection             (`frameSelection`, closed by default)
+ *       - Mode
+ *       - Max keyframes
+ *       - Overlap threshold
+ *       - Flow tunables           (`frameSelection.flow`, only when
+ *                                  mode === 'flow-based')
+ *           - Max corners
+ *           - Quality level
+ *           - Min distance
+ *           - Max translation cm
+ *           - Novelty percentile
+ *           - Eval every N frames
+ *   - Stitcher                    (`stitcher`, closed by default)
+ *       - Stitch mode
+ *       - Warper type
+ *       - Blender
+ *       - Seam finder
+ *       - Inscribed-rect crop
+ *   - Reset to defaults           (button)
+ *
+ * Note: `captureSource` (AR vs non-AR) is NOT surfaced here.  The
+ * camera-screen AR toggle owns that state — Camera.tsx overrides the
+ * native bridge's `captureSource` with the derived
+ * `effectiveCaptureSource` so settings and runtime stay in sync.
+ *
+ * The reusable `Accordion` + `SectionHeader` + `SegmentedControl` +
+ * `Tag` helpers from the v0.3 modal are preserved verbatim — only the
+ * data-binding layer changed.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -51,211 +87,64 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PANORAMA_SETTINGS = void 0;
 exports.PanoramaSettingsModal = PanoramaSettingsModal;
 const react_1 = __importStar(require("react"));
 const react_native_1 = require("react-native");
-// Per-device default selection.  We read the iPhone's physical
-// RAM at SDK module load (exposed by `BatchStitcher`'s
-// `constantsToExport`) and pick the heaviest blender + seam
-// finder combo that fits.  Threshold (2 GB) is conservative —
-// iPhone 6s through iPhone X have 2 GB exactly; below that
-// (iPhone 6 / 5s) is unsupported by RN 0.84 anyway.  The user
-// can still flip ANY of these in the settings modal at runtime;
-// this only chooses the INITIAL default.
-const _physicalMemoryBytes = (() => {
-    const m = react_native_1.NativeModules.BatchStitcher;
-    const bytes = m && typeof m === 'object'
-        ? m.physicalMemoryBytes
-        : undefined;
-    return typeof bytes === 'number' ? bytes : 0;
-})();
-const _isLowMem = _physicalMemoryBytes > 0
-    && _physicalMemoryBytes < 2 * 1024 * 1024 * 1024;
-// One-line diagnostic so the host's Metro console shows what the
-// SDK saw at module load.  If `physicalMemoryBytes=0` here, the
-// native bridge's `constantsToExport` isn't being picked up by
-// React Native and we should investigate the @objc registration.
-// The defaults always pick the SAFE fallback (multiband+graphcut)
-// when the value is 0 — this log is the only signal we have.
-// eslint-disable-next-line no-console
-console.log('[capture-sdk] PanoramaSettings defaults: '
-    + `physicalMemoryBytes=${_physicalMemoryBytes} `
-    + `isLowMem=${_isLowMem} `
-    + `→ blender=${_isLowMem ? 'feather' : 'multiband'} `
-    + `seam=${_isLowMem ? 'skip' : 'graphcut'}`);
-exports.DEFAULT_PANORAMA_SETTINGS = {
-    warperType: 'plane',
-    // High-quality defaults on devices with ≥2 GB RAM (iPhone X+):
-    // MultiBandBlender + GraphCutSeamFinder, the same combo
-    // cv::Stitcher::PANORAMA uses internally and what produced the
-    // sharpest output during iteration.
-    // Low-memory devices (<2 GB) fall back to FeatherBlender + skip
-    // seam (streams warp+feed) so peak memory stays under the
-    // tighter jetsam threshold.  Either way, the user can switch
-    // both in the settings modal.
-    blenderType: _isLowMem ? 'feather' : 'multiband',
-    seamFinderType: _isLowMem ? 'skip' : 'graphcut',
-    // V16 Phase 1b.fix5c — default OFF.  See PanoramaSettings.enableMaxInscribedRectCrop.
-    enableMaxInscribedRectCrop: false,
-    // AR-backed capture is the default — vision-camera path is kept as
-    // a fallback while we shake out edge cases.
-    useARPreview: true,
-    // V16 Phase 1 — batch-keyframe is the new default-recommended
-    // engine: KeyframeGate caps input at ≤ keyframeMaxCount frames,
-    // OpenCVStitcher's BA + GraphCut + ExposureCompensator +
-    // MultiBandBlender runs once on shutter release.  Existing
-    // slitscan-* engines remain available for wide-pan fallback.
-    incrementalEngine: 'batch-keyframe',
-    slitWidthFraction: 0.30,
-    acceptGate: 0,
-    enableTriangulation: false,
-    enableTriAccumulator: false,
-    enable2dNcc: false,
-    enableRansacHomography: false,
-    // V15.0c — Ram observation: FirstPaintedWins is consistently the best
-    // output across all combinations.  Default switched from FeatherBlend.
-    paintMode: 'FirstPaintedWins',
-    hybridProjection: 'Planar',
-    nccSearchRadius1d: 15,
-    useDetectedPlane: false,
-    // V16 Phase 1 — Virtual plane is the default since batch-keyframe
-    // is the recommended engine and the gate needs a plane to compute
-    // polygon overlap.  Virtual works without ARKit-detected planes (a
-    // synthesized plane perpendicular to the first-frame camera at
-    // virtualPlaneDepthMeters); operators can flip to ARKitDetected
-    // when in a controlled scene with a clearly-visible wall.  Disabled
-    // is still selectable for the older slit-scan paths that don't
-    // need a plane.
-    // V16 Phase 1b.fix5c (Ram's call 2026-05-10): switched default
-    // from 'Virtual' to 'ARKitDetected'.  ARKit's real plane gives
-    // better intrinsics-to-pixel alignment than a synthesised plane
-    // at a fixed depth, when ARKit can find a vertical plane.  Falls
-    // back to slit-scan when no plane latches.
-    planeSource: 'ARKitDetected',
-    virtualPlaneDepthMeters: 1.5,
-    arkitPlaneAlignmentThreshold: 0.6,
-    // V15.0g — Rectified is the default (Trapezoidal had the tilt-
-    // induced bottom-wider-than-top distortion that was the field
-    // blocker on V15.0e/f).  Trapezoidal stays available for
-    // operator A/B comparison.
-    planeProjectionStyle: 'Rectified',
-    // V15.0d — NCC 2D defaults match V15.0c.4's hardcoded values, now
-    // tunable via the settings UI.  EMA smoothing and pan-axis lock are
-    // off by default so the V15.0c.4 baseline behaviour is preserved
-    // until the operator explicitly opts in.
-    nccSearchMargin2d: 12,
-    // V15.0i.1 — default raised to 0.99 per Ram (only apply on near-
-    // perfect overlap matches; reject ambiguous matches that snap to
-    // wrong patterns on repetitive textures like shelf rails).
-    nccConfidenceThreshold2d: 0.99,
-    enableNcc2dEmaSmoothing: false,
-    ncc2dEmaAlpha: 0.4,
-    enableNcc2dPanAxisLock: false,
-    ncc2dCrossAxisLockPx: 5,
-    // V16 A2 (2026-05-13) — flow-based is now the default.  Ram report
-    // 2026-05-13 13:05 showed that pose-based on a small latched plane
-    // produces "bursts" of accepts on small physical motion: a 0.64 m²
-    // plane at 2.7 m perpDist gave 6 accepts in 1 s over 12 cm of
-    // translation because the plane-projected polygon covers only a
-    // sliver of the frame, hyperinflating newContent.  Flow-based
-    // measures novelty from real image content (sparse KLT), is
-    // plane-independent, and is invariant to plane size.  Operators
-    // can still flip back to 'pose-based' or 'time-based' in the modal
-    // for A/B testing or low-texture scenes.  Same defaults shared
-    // between pose-based and flow-based (40 % new content per
-    // keyframe, ≤ 6 keyframes per capture).
-    frameSelectionMode: 'flow-based',
-    // 2026-05-15 (U4) — flow-based default novelty 0.40 → 0.20.
-    // Accept frames with 20 % new content (was 40 %).  More inclusive
-    // selection for shelf-pan captures where panning slowly produces
-    // gradual content reveal.  Operator can still bump via Settings.
-    keyframeOverlapThreshold: 0.20,
-    keyframeMaxCount: 6,
-    // V16 A2 — flow-based mode tuning.  Defaults are the values that
-    // tested cleanly on iPhone 13 Pro / 14 Pro: 150 corners give a
-    // stable median across the frame; quality=0.01 + minDistance=10
-    // give spatially-spread, repeatable detection.  All three are
-    // tunable in the modal under "Flow tuning".
-    flowMaxCorners: 150,
-    flowQualityLevel: 0.01,
-    flowMinDistance: 10,
-    // V16 — translation-budget force-accept (Flow strategy only).
-    // 2026-05-16 (Issue 4a fix) — default flipped from 0 (disabled) to
-    // 25 cm so the "Rotate the camera instead of moving it sideways"
-    // warning fires out-of-the-box.  Set to 0 in Settings to disable
-    // both the warning AND the gate's force-accept on budget crossing.
-    // 2026-05-17 (Issue 4-A v2) — raised 25 → 50 cm.  The 25-cm budget
-    // was too tight given IMU double-integration drift (the
-    // accelerometer's noise floor accumulates several cm of bogus
-    // "translation" per second even when the phone is held still).
-    // Combined with the new `resetAnchor` at handleHoldStart (so drift
-    // doesn't compound across captures), 50 cm gives the warning real
-    // headroom for genuine sideways motion without false positives.
-    flowMaxTranslationCm: 50,
-    // V16 — novelty aggregation percentile.  0.85 picks up leading-
-    // edge motion sooner than the pre-V16 median (0.50).  Operator
-    // can dial down toward 0.5 for more-conservative captures or up
-    // toward 0.99 for more-aggressive.
-    flowNoveltyPercentile: 0.85,
-    // V16 — every-Nth-frame eval throttle.  2026-05-15 (U4): default
-    // 1 → 5 to reduce per-frame KeyframeGate CPU cost (Shi-Tomasi +
-    // calcOpticalFlowPyrLK is ~3-5 ms per ARFrame on Galaxy A35; at
-    // 30 fps that's ~15 % CPU on flow alone).  Evaluating every 5th
-    // frame yields novelty samples at ~6 Hz which is still well above
-    // the 1-2 Hz keyframe-accept cadence.
-    // matches pre-V16 behaviour).  Set higher to cut CPU on long
-    // captures at the cost of acceptance latency.
-    flowEvalEveryNFrames: 5,
-    // V15.0c — sliver tweaks: leading-edge sliver from BOTTOM for typical
-    // top-to-bottom pan + full first-frame anchor produced the best
-    // outputs in early iteration.
-    sliverPosition: 'Bottom',
-    firstFrameFullFrame: true,
-    maxRecordingMs: 8000,
-    framesPerSecond: 3,
-    minFrames: 6,
-    maxFrames: 16,
-    quality: 85,
-    // 2026-05-14 (revised) — capture source defaults to 'ar' (AR-backed
-    // is the recommended path; non-AR is the explicit opt-out).  Stitch
-    // mode stays 'auto' — the auto-resolution heuristic between PANORAMA
-    // and SCANS is per-capture, not per-mode, so it's safe to leave on.
-    captureSource: 'ar',
-    stitchMode: 'auto',
-    debug: false,
-};
+const PanoramaSettings_1 = require("./PanoramaSettings");
+const lowMemDevice_1 = require("./lowMemDevice");
+// ─── Device-memory diagnostic (informational only) ─────────────────
+//
+// Read once at module load via the shared `lowMemDevice` helper.  We
+// surface this as a single Menlo-monospace line at the top of the
+// modal body so operators can see what the SDK detected — useful for
+// diagnosing "why am I OOMing on this device?" questions.  The same
+// helper feeds <Camera>'s initial-settings device adaptation; they
+// were duplicated implementations pre-Phase-2-fix.
+const _physicalMemoryBytes = (0, lowMemDevice_1.getPhysicalMemoryBytes)();
+const _isLowMem = (0, lowMemDevice_1.isLowMemDevice)();
 function PanoramaSettingsModal({ visible, settings, onChange, onClose, }) {
-    const update = (patch) => onChange({ ...settings, ...patch });
-    // V16 Phase 1b — derive the 2-axis (timing × algorithm) UI state
-    // from the underlying single `incrementalEngine` field.  Storage
-    // shape is unchanged; the modal just presents it in two segmented
-    // controls so the user's mental model matches the system's actual
-    // primary axis (batch vs realtime).
+    // ─── Sub-tree update helpers ─────────────────────────────────────
     //
-    // Mapping:
-    //   incrementalEngine === 'batch-keyframe'  → timing='batch'
-    //   incrementalEngine === 'hybrid'          → timing='realtime', algo='hybrid'
-    //   incrementalEngine === 'slitscan-rotate' → timing='realtime', algo='slitscan-rotate'
-    //   incrementalEngine === 'slitscan-both'   → timing='realtime', algo='slitscan-both'
-    const timing = settings.incrementalEngine === 'batch-keyframe' ? 'batch' : 'realtime';
-    // When in batch mode, remember 'hybrid' as the realtime algorithm
-    // the user would land on if they flipped timing back.  When already
-    // in realtime, the engine field IS the algorithm.
-    const realtimeAlgorithm = settings.incrementalEngine === 'batch-keyframe'
-        ? 'hybrid'
-        : settings.incrementalEngine;
-    const setTiming = (t) => {
-        if (t === 'batch') {
-            update({ incrementalEngine: 'batch-keyframe' });
-        }
-        else {
-            update({ incrementalEngine: realtimeAlgorithm });
-        }
-    };
-    // Frame Selection only makes sense for batch and hybrid engines —
-    // slit-scan needs dense input and the gate would starve it.
-    const showFrameSelection = timing === 'batch' || realtimeAlgorithm === 'hybrid';
+    // Each settings sub-tree has its own update helper that
+    // non-destructively patches that branch and re-emits the whole
+    // settings object via `onChange`.  Call sites stay short
+    // (`updateStitcher({ stitchMode: 'scans' })`) and avoid the
+    // nested-spread boilerplate the hierarchical shape would otherwise
+    // require at every callsite.
+    //
+    // Why not a generic deep-merge?  Type-safety: each helper takes
+    // exactly the `Partial<SubTree>` the section it backs can patch.
+    // A generic helper would accept arbitrary nested keys and break the
+    // type-level guarantee that the modal only mutates what its
+    // matching settings type defines.
+    const updateBase = (patch) => onChange({ ...settings, ...patch });
+    const updateStitcher = (patch) => onChange({
+        ...settings,
+        stitcher: { ...settings.stitcher, ...patch },
+    });
+    const updateFrameSelection = (patch) => onChange({
+        ...settings,
+        frameSelection: { ...settings.frameSelection, ...patch },
+    });
+    // Flow has an extra wrinkle: `frameSelection.flow` is optional.
+    // We materialise it from `DEFAULT_FLOW_GATE_SETTINGS` (the
+    // canonical FlowGateSettings defaults — see PanoramaSettings.ts)
+    // when patching from "undefined" — happens if a host starts with
+    // a custom settings literal that omits the sub-tree.
+    const updateFlow = (patch) => onChange({
+        ...settings,
+        frameSelection: {
+            ...settings.frameSelection,
+            flow: {
+                ...(settings.frameSelection.flow ?? PanoramaSettings_1.DEFAULT_FLOW_GATE_SETTINGS),
+                ...patch,
+            },
+        },
+    });
+    // Frame-selection mode controls the visibility of the nested
+    // Flow-tunables section.  Mirrors the type-level optionality of
+    // `frameSelection.flow`.
+    const showFlowTunables = settings.frameSelection.mode === 'flow-based';
     return (react_1.default.createElement(react_native_1.Modal, { visible: visible, animationType: "slide", transparent: true, statusBarTranslucent: true, onRequestClose: onClose },
         react_1.default.createElement(react_native_1.View, { style: styles.backdrop },
             react_1.default.createElement(react_native_1.View, { style: styles.sheet },
@@ -267,130 +156,84 @@ function PanoramaSettingsModal({ visible, settings, onChange, onClose, }) {
                     react_1.default.createElement(react_native_1.Text, { style: styles.debugLine }, `device: physicalMemoryBytes=${_physicalMemoryBytes} `
                         + `(${(_physicalMemoryBytes / (1024 ** 3)).toFixed(2)} GB) · `
                         + `isLowMem=${_isLowMem ? 'yes' : 'no'} · `
-                        + `default blender=${_isLowMem ? 'feather' : 'multiband'}`),
-                    react_1.default.createElement(SectionHeader, { title: "Capture source" }),
-                    react_1.default.createElement(SegmentedControl, { options: ['ar', 'non-ar'], value: settings.captureSource, onChange: (v) => update({ captureSource: v }), caption: "ar (default): ARKit / ARCore \u2014 plane detection, pose-aware capture, full AR stack.  non-ar: vision-camera only \u2014 disables AR plane detection, flips frame-selection to flow-based, runs IMU translation gate.  In non-ar mode, the on-screen lens-switcher chip lets you toggle 0.5\u00D7 / 1\u00D7 lens during capture (only shown when the device has both lenses)." }),
-                    react_1.default.createElement(SectionHeader, { title: "Stitch mode" }),
-                    react_1.default.createElement(SegmentedControl, { options: ['auto', 'panorama', 'scans'], value: settings.stitchMode, onChange: (v) => update({ stitchMode: v }), caption: "auto (default): pick PANORAMA or SCANS based on translation/rotation totals at finalize. panorama: cv::Stitcher::PANORAMA \u2014 rotation-only (spherical warper, BA-ray); best for rotate-in-place captures, BAD on translation. scans: cv::Stitcher::SCANS \u2014 affine pipeline (plane warper, BA-affine); best for shelf-pan captures." }),
-                    react_1.default.createElement(SectionHeader, { title: "Stitch timing" }),
-                    react_1.default.createElement(SegmentedControl, { options: ['batch', 'realtime'], value: timing, onChange: (v) => setTiming(v), caption: "batch (recommended): full cv::Stitcher pipeline at shutter release. Highest quality. ~1\u20132 s post-release. realtime: incremental during pan; lower latency, fewer quality stages." }),
-                    showFrameSelection && (react_1.default.createElement(react_1.default.Fragment, null,
-                        react_1.default.createElement(SectionHeader, { title: "Frame selection (V16)" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['time-based', 'pose-based', 'flow-based'], value: settings.frameSelectionMode, onChange: (v) => update({ frameSelectionMode: v }), caption: "flow-based (V16 A2, default): KeyframeGate uses sparse-Lucas-Kanade optical flow on full frame \u2014 plane-independent, invariant to plane size. pose-based: plane-polygon overlap (oversensitive on small latched planes). time-based: every ARFrame goes to the engine." }),
-                        (settings.frameSelectionMode === 'pose-based' ||
-                            settings.frameSelectionMode === 'flow-based') && (react_1.default.createElement(react_1.default.Fragment, null,
-                            react_1.default.createElement(SectionHeader, { title: "Overlap threshold (new content per keyframe)" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['20%', '30%', '40%', '50%', '60%'], value: `${Math.round(settings.keyframeOverlapThreshold * 100)}%`, onChange: (v) => update({ keyframeOverlapThreshold: parseInt(v, 10) / 100 }), caption: "Required NEW content per keyframe. 40% (default) \u2248 4\u20135 keyframes for a 90\u00B0 pan. Same threshold semantics for both pose-based and flow-based." }),
-                            react_1.default.createElement(SectionHeader, { title: "Max keyframes per capture" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['3', '4', '5', '6', '8', '10'], value: String(settings.keyframeMaxCount), onChange: (v) => update({ keyframeMaxCount: parseInt(v, 10) }), caption: "Hard cap. 6 (default) matches Samsung's behaviour. Once reached, host auto-finalizes." }))),
-                        settings.frameSelectionMode === 'flow-based' && (react_1.default.createElement(react_1.default.Fragment, null,
-                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 max corners" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['50', '100', '150', '200', '300'], value: String(settings.flowMaxCorners), onChange: (v) => update({ flowMaxCorners: parseInt(v, 10) }), caption: "Max Shi-Tomasi corners detected per accepted keyframe. More = more robust median, slower detect. 150 = default." }),
-                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 quality level" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['0.005', '0.01', '0.02', '0.03', '0.05'], value: String(settings.flowQualityLevel), onChange: (v) => update({ flowQualityLevel: parseFloat(v) }), caption: "Shi-Tomasi corner quality threshold. Lower = more (weaker) corners; higher = fewer (stronger) corners. 0.01 = default." }),
-                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 min distance" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['5', '8', '10', '15', '20'], value: String(settings.flowMinDistance), onChange: (v) => update({ flowMinDistance: parseInt(v, 10) }), caption: "Min pixel distance between detected corners (working resolution = 720 px longest side). Higher = more spatially-spread features. 10 = default." }),
-                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 translation budget (cm)" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['0', '5', '8', '12', '20', '50'], value: String(settings.flowMaxTranslationCm), onChange: (v) => update({ flowMaxTranslationCm: parseInt(v, 10) }), caption: "Force-accept when camera has moved this many cm since last keyframe, even if novelty < overlap threshold. Bounds parallax so the stitcher can match. 0 = disabled (default). 8 = recommended starting value." }),
-                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 novelty percentile" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['0.50', '0.70', '0.85', '0.95', '0.99'], value: settings.flowNoveltyPercentile.toFixed(2), onChange: (v) => update({ flowNoveltyPercentile: parseFloat(v) }), caption: "How tracked-feature displacements are aggregated into novelty. 0.50 = pre-V16 median behaviour (conservative). 0.85 = picks up leading-edge motion sooner (default, matches user perception). 0.99 = near-max, very aggressive." }),
-                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 eval every N frames" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['1', '2', '3', '5', '10'], value: String(settings.flowEvalEveryNFrames), onChange: (v) => update({ flowEvalEveryNFrames: parseInt(v, 10) }), caption: "Throttle gate evaluation to every Nth AR frame. 1 = every frame (default, no throttle). 3-5 = noticeable CPU/battery savings on long captures, up to N-1 frames of acceptance latency." }))))),
-                    react_1.default.createElement(SectionHeader, { title: "AR plane projection" }),
-                    react_1.default.createElement(SegmentedControl, { options: ['Disabled', 'ARKitDetected', 'Virtual'], value: settings.planeSource, onChange: (v) => update({ planeSource: v }), caption: "Disabled: no plane (gate falls back to angular delta). ARKitDetected: latch ARKit's vertical plane (best fidelity, picky). Virtual: synthesise plane perpendicular to camera at a fixed depth (always works)." }),
-                    settings.planeSource === 'ARKitDetected' && (react_1.default.createElement(react_1.default.Fragment, null,
-                        react_1.default.createElement(SectionHeader, { title: "ARKit alignment threshold" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['0.3', '0.5', '0.6', '0.7', '0.85'], value: settings.arkitPlaneAlignmentThreshold.toFixed(2), onChange: (v) => update({ arkitPlaneAlignmentThreshold: parseFloat(v) }), caption: "Min dot product between candidate plane normal and camera facing. 0.6 (default) = ~53\u00B0 max angle off-camera. Higher = stricter." }))),
-                    settings.planeSource === 'Virtual' && (react_1.default.createElement(react_1.default.Fragment, null,
-                        react_1.default.createElement(SectionHeader, { title: "Virtual plane depth" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['0.5m', '1.0m', '1.5m', '2.0m', '3.0m'], value: `${settings.virtualPlaneDepthMeters.toFixed(1)}m`, onChange: (v) => update({ virtualPlaneDepthMeters: parseFloat(v) }), caption: "Synthetic plane depth at first frame. Set to your typical scan distance." }))),
-                    settings.planeSource !== 'Disabled' && (react_1.default.createElement(react_1.default.Fragment, null,
-                        react_1.default.createElement(SectionHeader, { title: "Plane projection style" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['Rectified', 'Trapezoidal'], value: settings.planeProjectionStyle, onChange: (v) => update({ planeProjectionStyle: v }), caption: "Rectified (default): clean rectangle paste, no tilt distortion. Trapezoidal: V15.0b legacy 3D-correct raycast \u2014 geometric purity at the cost of tilt artifacts." }))),
-                    react_1.default.createElement(SectionHeader, { title: "Algorithm" }),
-                    timing === 'batch' ? (react_1.default.createElement(react_native_1.View, { style: styles.infoBox },
-                        react_1.default.createElement(react_native_1.Text, { style: styles.infoText }, "Full feature-matched pipeline: ORB \u2192 BFMatcher \u2192 RANSAC \u2192 BundleAdjusterRay \u2192 waveCorrect \u2192 Warper \u2192 GraphCutSeamFinder \u2192 ExposureCompensator \u2192 MultiBandBlender. No engine choice in batch mode."))) : (react_1.default.createElement(SegmentedControl, { options: ['hybrid', 'slitscan-rotate', 'slitscan-both'], value: realtimeAlgorithm, onChange: (v) => update({ incrementalEngine: v }), caption: "hybrid: streaming planar projection + feature matching. slitscan-rotate: V13.0a + 1D NCC. slitscan-both: V13.0a + no accept gate + feather blend (iteration playground)." })),
-                    timing === 'batch' && (react_1.default.createElement(react_1.default.Fragment, null,
-                        react_1.default.createElement(SectionHeader, { title: "Batch tuning \u2014 Warper" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['plane', 'cylindrical', 'spherical'], value: settings.warperType, onChange: (v) => update({ warperType: v }), caption: "plane (default, recommended for retail shelves): flat rectangular output. cylindrical: rotational mid-arc, gentle curvature. spherical: wide pans (180\u00B0+) but always-curved." }),
-                        react_1.default.createElement(SectionHeader, { title: "Batch tuning \u2014 Blender" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['multiband', 'feather'], value: settings.blenderType, onChange: (v) => update({ blenderType: v }), caption: "multiband (default): Laplacian-pyramid blending; cleanest seams. feather: faster, no halo when exposure varies." }),
-                        react_1.default.createElement(SectionHeader, { title: "Batch tuning \u2014 Seam finder" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['graphcut', 'skip'], value: settings.seamFinderType, onChange: (v) => update({ seamFinderType: v }), caption: "graphcut (default): cv::detail::GraphCutSeamFinder; optimal seams, pairs with multiband, holds all warps in memory. skip: stream warp+feed (lower peak memory)." }),
-                        react_1.default.createElement(SectionHeader, { title: "Batch tuning \u2014 Inscribed-rect crop" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableMaxInscribedRectCrop ? 'on' : 'off', onChange: (v) => update({ enableMaxInscribedRectCrop: v === 'on' }), caption: "off (default): final crop is just cv::boundingRect of non-black pixels \u2014 preserves all stitched content; may have black corners. on: additionally run MaxInscribedRectFromMask + column-projection second-pass for a clean-cornered rectangle \u2014 can shrink the output if the panorama mask is lopsided. A/B against the bbox crop on real scenes." }))),
-                    timing === 'realtime' && realtimeAlgorithm === 'hybrid' && (react_1.default.createElement(react_1.default.Fragment, null,
-                        react_1.default.createElement(SectionHeader, { title: "Hybrid tuning \u2014 Projection" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['Planar', 'Cylindrical'], value: settings.hybridProjection, onChange: (v) => update({ hybridProjection: v }), caption: "Planar (default): cv::detail::PlaneWarper. Cylindrical: V12.x \u2013 V14.0a behaviour (legacy)." }))),
-                    timing === 'realtime' && realtimeAlgorithm.startsWith('slitscan') && (react_1.default.createElement(react_1.default.Fragment, null,
-                        react_1.default.createElement(SectionHeader, { title: "Slit-scan tuning \u2014 Slit width" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['0.01', '0.05', '0.10', '0.20', '0.30', '0.50'], value: settings.slitWidthFraction.toFixed(2), onChange: (v) => update({ slitWidthFraction: parseFloat(v) }), caption: "Fraction of pan-axis retained per sliver. 0.30 (V15 default) \u2248 324 px. Smaller = less within-slit depth disagreement." }),
-                        react_1.default.createElement(SectionHeader, { title: "Slit-scan tuning \u2014 Sliver position" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['Center', 'Bottom', 'Top'], value: settings.sliverPosition, onChange: (v) => update({ sliverPosition: v }), caption: "Where on the camera sensor frame the sliver is taken." }),
-                        react_1.default.createElement(SectionHeader, { title: "Slit-scan tuning \u2014 Full first-frame" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.firstFrameFullFrame ? 'on' : 'off', onChange: (v) => update({ firstFrameFullFrame: v === 'on' }), caption: "ON: first accepted frame paints the full camera frame at the canvas anchor; subsequent frames use sliver clip." }),
-                        react_1.default.createElement(SectionHeader, { title: "Slit-scan tuning \u2014 Paint mode" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['FirstPaintedWins', 'FeatherBlend'], value: settings.paintMode, onChange: (v) => update({ paintMode: v }), caption: "FirstPaintedWins (default): protect already-painted pixels. FeatherBlend: alpha-blend new content into overlap." }))),
-                    react_1.default.createElement(Accordion, { title: "Advanced \u2014 2D NCC fine-alignment", badge: "advanced" },
-                        react_1.default.createElement(SectionHeader, { title: "Enable 2D NCC" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enable2dNcc ? 'on' : 'off', onChange: (v) => update({ enable2dNcc: v === 'on' }), caption: "V13.0g 2D NCC fine-alignment after pose-driven projection. Refines (\u0394x, \u0394y) translation via cv::matchTemplate." }),
-                        settings.enable2dNcc && (react_1.default.createElement(react_1.default.Fragment, null,
-                            react_1.default.createElement(SectionHeader, { title: "Confidence threshold" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['0.50', '0.65', '0.75', '0.85', '0.95', '0.99'], value: settings.nccConfidenceThreshold2d.toFixed(2), onChange: (v) => update({ nccConfidenceThreshold2d: parseFloat(v) }), caption: "Reject NCC corrections below this confidence. 0.99 = only apply on near-perfect overlap." }),
-                            react_1.default.createElement(SectionHeader, { title: "Search half-window (px)" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['6', '10', '12', '20', '30'], value: String(settings.nccSearchMargin2d), onChange: (v) => update({ nccSearchMargin2d: parseInt(v, 10) }), caption: "Pixels: 2D NCC searches \u00B1this around the pose-predicted match." }),
-                            react_1.default.createElement(SectionHeader, { title: "EMA smoothing" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableNcc2dEmaSmoothing ? 'on' : 'off', onChange: (v) => update({ enableNcc2dEmaSmoothing: v === 'on' }), caption: "Damp single-frame snaps to spurious peaks via EMA." }),
-                            settings.enableNcc2dEmaSmoothing && (react_1.default.createElement(react_1.default.Fragment, null,
-                                react_1.default.createElement(SectionHeader, { title: "EMA alpha (current-frame weight)" }),
-                                react_1.default.createElement(SegmentedControl, { options: ['0.20', '0.30', '0.40', '0.60', '0.80'], value: settings.ncc2dEmaAlpha.toFixed(2), onChange: (v) => update({ ncc2dEmaAlpha: parseFloat(v) }) }))),
-                            react_1.default.createElement(SectionHeader, { title: "Pan-axis lock" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableNcc2dPanAxisLock ? 'on' : 'off', onChange: (v) => update({ enableNcc2dPanAxisLock: v === 'on' }), caption: "Clamp cross-axis correction tighter than pan-axis (pose + 1D NCC handle cross-axis already)." }),
-                            settings.enableNcc2dPanAxisLock && (react_1.default.createElement(react_1.default.Fragment, null,
-                                react_1.default.createElement(SectionHeader, { title: "Cross-axis clamp (px)" }),
-                                react_1.default.createElement(SegmentedControl, { options: ['2', '5', '10', '15'], value: String(settings.ncc2dCrossAxisLockPx), onChange: (v) => update({ ncc2dCrossAxisLockPx: parseInt(v, 10) }) })))))),
-                    timing === 'realtime' && realtimeAlgorithm === 'slitscan-both' && (react_1.default.createElement(Accordion, { title: "Advanced \u2014 Slit-scan experimental", badge: "experimental" },
-                        react_1.default.createElement(SectionHeader, { title: "Triangulation parallax" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableTriangulation ? 'on' : 'off', onChange: (v) => update({ enableTriangulation: v === 'on' }), caption: "V13.0e ORB triangulation + median-Z parallax correction. Adds ~10ms/accept." }),
-                        react_1.default.createElement(SectionHeader, { title: "RANSAC homography" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableRansacHomography ? 'on' : 'off', onChange: (v) => update({ enableRansacHomography: v === 'on' }), caption: "V14.0a RANSAC homography per slit + cv::warpPerspective. Known limitation: can absorb pan as scale, leaving gaps." }),
-                        react_1.default.createElement(SectionHeader, { title: "Accept gate (px)" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['0', '50'], value: String(settings.acceptGate), onChange: (v) => update({ acceptGate: parseInt(v, 10) }), caption: "0 = accept on every frame (Apple-dense). 50 = V13.0g throttle." }))),
-                    react_1.default.createElement(SectionHeader, { title: "Recording cap" }),
-                    react_1.default.createElement(SegmentedControl, { options: ['4 s', '6 s', '8 s', '10 s'], value: `${Math.round(settings.maxRecordingMs / 1000)} s`, onChange: (v) => update({ maxRecordingMs: parseInt(v, 10) * 1000 }), caption: "Auto-stops the hold-recording at this duration." }),
-                    react_1.default.createElement(SectionHeader, { title: "JPEG quality" }),
-                    react_1.default.createElement(SegmentedControl, { options: ['70', '85', '92'], value: String(settings.quality), onChange: (v) => update({ quality: parseInt(v, 10) }), caption: "Higher = bigger files, sharper detail. 85 is the recommended default." }),
+                        + `current blender=${settings.stitcher.blenderType} `
+                        + `(low-mem fallback=${_isLowMem ? 'feather' : 'multiband'})`),
                     react_1.default.createElement(SectionHeader, { title: "Debug" }),
-                    react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.debug ? 'on' : 'off', onChange: (v) => update({ debug: v === 'on' }), caption: "When ON, every successful stitch shows a popup with the C+D progressive-confidence retry telemetry (frames included, final threshold, retry attempts). Off by default." }),
-                    react_1.default.createElement(Accordion, { title: "Diagnostics / fallbacks", badge: "rarely needed" },
-                        react_1.default.createElement(react_native_1.View, { style: styles.infoBox },
-                            react_1.default.createElement(react_native_1.Text, { style: styles.infoText }, "AR-backed capture is the recommended path. Toggle off ONLY if ARKit fails on a specific device (very rare on modern iPhones). Doing so falls back to vision-camera video recording + post-stitch via cv::Stitcher.")),
-                        react_1.default.createElement(SectionHeader, { title: "AR-backed capture" }),
-                        react_1.default.createElement(SegmentedControl, { options: ['on', 'off'], value: settings.useARPreview ? 'on' : 'off', onChange: (v) => update({ useARPreview: v === 'on' }), caption: "Default ON. OFF only when ARKit is unavailable or for A/B testing." }),
-                        !settings.useARPreview && (react_1.default.createElement(react_1.default.Fragment, null,
-                            react_1.default.createElement(SectionHeader, { title: "Frame extraction \u2014 Frames per second" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['2', '3', '4'], value: String(settings.framesPerSecond), onChange: (v) => update({ framesPerSecond: parseInt(v, 10) }), caption: "Frames/sec extracted from the recorded video. Lower = faster but riskier overlap." }),
-                            react_1.default.createElement(SectionHeader, { title: "Frame extraction \u2014 Frame count clamp" }),
-                            react_1.default.createElement(SegmentedControl, { options: ['4-12', '6-16', '8-20'], value: `${settings.minFrames}-${settings.maxFrames}`, onChange: (v) => {
-                                    const [min, max] = v.split('-').map((n) => parseInt(n, 10));
-                                    update({ minFrames: min, maxFrames: max });
-                                }, caption: "Floor/ceiling for extracted frames." })))),
-                    react_1.default.createElement(react_native_1.Pressable, { onPress: () => onChange(exports.DEFAULT_PANORAMA_SETTINGS), style: styles.resetBtn, accessibilityRole: "button", accessibilityLabel: "Reset to defaults" },
+                    react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.debug ? 'on' : 'off', onChange: (v) => updateBase({ debug: v === 'on' }), caption: "When ON, <Camera> mounts the diagnostic pills (memory, keyframes, orientation), the detailed metrics overlay, and the stitch-stats toast on every successful finalize.  OFF (default) \u2014 production end-user UI." }),
+                    react_1.default.createElement(Accordion, { title: "Frame selection (KeyframeGate)" },
+                        react_1.default.createElement(SectionHeader, { title: "Mode" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['time-based', 'pose-based', 'flow-based'], value: settings.frameSelection.mode, onChange: (v) => updateFrameSelection({
+                                mode: v,
+                            }), caption: "flow-based (default): sparse Shi-Tomasi + KLT optical flow.  Plane-independent.  pose-based: plane-overlap when a plane is latched, angular fallback otherwise \u2014 cheap but conservative.  time-based: gate disabled; every frame accepted up to maxKeyframes." }),
+                        react_1.default.createElement(SectionHeader, { title: "Max keyframes per capture" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['3', '4', '5', '6', '8', '10'], value: String(settings.frameSelection.maxKeyframes), onChange: (v) => updateFrameSelection({
+                                maxKeyframes: parseInt(v, 10),
+                            }), caption: "Hard cap on accepted keyframes; native clamps to [3, 10].  6 (default) matches Samsung Pano's behaviour and is the sweet spot for cv::Stitcher BA convergence." }),
+                        react_1.default.createElement(SectionHeader, { title: "Overlap threshold (new content per keyframe)" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['20%', '30%', '40%', '50%', '60%'], value: `${Math.round(settings.frameSelection.overlapThreshold * 100)}%`, onChange: (v) => updateFrameSelection({
+                                overlapThreshold: parseInt(v, 10) / 100,
+                            }), caption: "Required NEW-content fraction.  20% (default): generous, ~5\u20136 keyframes for a 90\u00B0 pan.  Native clamps to [10%, 80%]." }),
+                        showFlowTunables && (react_1.default.createElement(react_native_1.View, { style: styles.nested },
+                            react_1.default.createElement(react_native_1.Text, { style: styles.nestedLabel }, "Flow tuning"),
+                            react_1.default.createElement(SectionHeader, { title: "Max corners (Shi-Tomasi)" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['50', '100', '150', '200', '300'], value: String(settings.frameSelection.flow?.maxCorners
+                                    ?? PanoramaSettings_1.DEFAULT_FLOW_GATE_SETTINGS.maxCorners), onChange: (v) => updateFlow({ maxCorners: parseInt(v, 10) }), caption: "More corners = more robust median displacement, slower detect.  150 (default) ~ 15\u201325 ms / frame on Galaxy A35.  Native clamps to [50, 300]." }),
+                            react_1.default.createElement(SectionHeader, { title: "Quality level (Shi-Tomasi)" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['0.005', '0.01', '0.02', '0.03', '0.05'], value: String(settings.frameSelection.flow?.qualityLevel
+                                    ?? PanoramaSettings_1.DEFAULT_FLOW_GATE_SETTINGS.qualityLevel), onChange: (v) => updateFlow({ qualityLevel: parseFloat(v) }), caption: "Lower lets weaker corners in; higher demands stronger corners.  0.01 (default).  Clamped to [0.005, 0.05]." }),
+                            react_1.default.createElement(SectionHeader, { title: "Min distance (working-resolution px)" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['5', '8', '10', '15', '20'], value: String(settings.frameSelection.flow?.minDistance
+                                    ?? PanoramaSettings_1.DEFAULT_FLOW_GATE_SETTINGS.minDistance), onChange: (v) => updateFlow({ minDistance: parseInt(v, 10) }), caption: "Min pixel distance between detected corners (working res = 720 px longest side).  10 (default).  Clamped to [1, 50]." }),
+                            react_1.default.createElement(SectionHeader, { title: "Translation budget (cm)" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['0', '5', '8', '12', '20', '50'], value: String(settings.frameSelection.flow?.maxTranslationCm
+                                    ?? PanoramaSettings_1.DEFAULT_FLOW_GATE_SETTINGS.maxTranslationCm), onChange: (v) => updateFlow({
+                                    maxTranslationCm: parseInt(v, 10),
+                                }), caption: "Force-accept the next frame once the operator has translated this many cm since the last keyframe, even when novelty < threshold.  Bounds parallax so cv::Stitcher's matcher can handle the input.  50 (default).  0 disables.  Clamped to [0, 100]." }),
+                            react_1.default.createElement(SectionHeader, { title: "Novelty percentile" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['0.50', '0.70', '0.85', '0.95', '0.99'], value: (settings.frameSelection.flow?.noveltyPercentile
+                                    ?? PanoramaSettings_1.DEFAULT_FLOW_GATE_SETTINGS.noveltyPercentile).toFixed(2), onChange: (v) => updateFlow({
+                                    noveltyPercentile: parseFloat(v),
+                                }), caption: "How tracked-feature displacements aggregate into a per-axis novelty estimate.  0.85 (default): picks up leading-edge motion sooner \u2014 matches user perception.  0.50: pre-V16 median (conservative).  0.99: very aggressive.  Clamped to [0.50, 0.99]." }),
+                            react_1.default.createElement(SectionHeader, { title: "Eval every N frames" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['1', '2', '3', '5', '10'], value: String(settings.frameSelection.flow?.evalEveryNFrames
+                                    ?? PanoramaSettings_1.DEFAULT_FLOW_GATE_SETTINGS.evalEveryNFrames), onChange: (v) => updateFlow({
+                                    evalEveryNFrames: parseInt(v, 10),
+                                }), caption: "Throttle gate evaluation to every Nth frame for CPU savings.  5 (default) gives ~6 Hz novelty samples at 30 Hz ARCore.  Doesn't change WHICH frames are accepted; only the sample rate.  Clamped to [1, 10]." })))),
+                    react_1.default.createElement(Accordion, { title: "Stitcher (cv::Stitcher knobs)" },
+                        react_1.default.createElement(SectionHeader, { title: "Stitch mode" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['auto', 'panorama', 'scans'], value: settings.stitcher.stitchMode, onChange: (v) => updateStitcher({
+                                stitchMode: v,
+                            }), caption: "auto (default): pick PANORAMA or SCANS based on translation/rotation totals at finalize.  panorama: rotation-only (spherical warper, BA-Ray) \u2014 best for rotate-in-place captures; BAD on translation.  scans: affine pipeline (plane warper, BA-affine) \u2014 best for shelf-pan captures; never diverges on rotation either.  Both modes auto-retry with the opposite if camera params come out degenerate." }),
+                        react_1.default.createElement(SectionHeader, { title: "Warper" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['plane', 'cylindrical', 'spherical'], value: settings.stitcher.warperType, onChange: (v) => updateStitcher({
+                                warperType: v,
+                            }), caption: "plane (default): flat rectangular output, best for retail shelves.  cylindrical: rotational mid-arc.  spherical: wide pans (180\u00B0+), always curved.  Only consulted in panorama mode; scans hardwires PlaneWarper." }),
+                        react_1.default.createElement(SectionHeader, { title: "Blender" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['multiband', 'feather'], value: settings.stitcher.blenderType, onChange: (v) => updateStitcher({
+                                blenderType: v,
+                            }), caption: "multiband (default): Laplacian-pyramid blending; cleanest seams, holds all warped frames in memory.  feather: streams warp+feed (lower peak memory, no halo with varied exposure).  <Camera> auto-picks feather on low-memory devices." }),
+                        react_1.default.createElement(SectionHeader, { title: "Seam finder" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['graphcut', 'skip'], value: settings.stitcher.seamFinderType, onChange: (v) => updateStitcher({
+                                seamFinderType: v,
+                            }), caption: "graphcut (default): cv::detail::GraphCutSeamFinder for optimal seams; pairs with multiband.  skip: stream warp+feed (lowest-memory configuration; pair with feather)." }),
+                        react_1.default.createElement(SectionHeader, { title: "Inscribed-rect crop" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.stitcher.enableMaxInscribedRectCrop ? 'on' : 'off', onChange: (v) => updateStitcher({
+                                enableMaxInscribedRectCrop: v === 'on',
+                            }), caption: "off (default): crop to cv::boundingRect of non-black pixels \u2014 preserves all stitched content; may leave black corners.  on: run MaxInscribedRectFromMask + column-projection second-pass for a clean rectangle (can shrink output if mask is lopsided)." })),
+                    react_1.default.createElement(react_native_1.Pressable, { onPress: () => onChange(PanoramaSettings_1.DEFAULT_PANORAMA_SETTINGS), style: styles.resetBtn, accessibilityRole: "button", accessibilityLabel: "Reset to defaults" },
                         react_1.default.createElement(react_native_1.Text, { style: styles.resetText }, "Reset to defaults")))))));
 }
+// ════════════════════════════════════════════════════════════════════
+// Helpers (kept verbatim from v0.3 — presentational primitives the
+// modal composes; nothing in here depends on the settings shape).
+// ════════════════════════════════════════════════════════════════════
 function SectionHeader({ title }) {
     return react_1.default.createElement(react_native_1.Text, { style: styles.sectionHeader }, title);
 }
 /**
- * Collapsible section.  Used for closed-by-default groupings
- * ("Advanced", "Diagnostics / fallbacks") so the modal's primary
- * surface stays focused on the controls operators actually touch
- * day-to-day.
- *
- * State is local — each Accordion instance manages its own open
- * flag.  The modal opens fresh-collapsed every mount which is what
- * we want for now; persisting open state across mounts (e.g. via
- * AsyncStorage) is a future enhancement.
+ * Collapsible section.  Each instance owns its open/closed state;
+ * the modal opens fresh-collapsed on every mount, which is what we
+ * want (no AsyncStorage roundtrip on every settings tweak).
  */
 function Accordion({ title, initiallyOpen = false, badge, children, }) {
     const [open, setOpen] = (0, react_1.useState)(initiallyOpen);
@@ -402,9 +245,10 @@ function Accordion({ title, initiallyOpen = false, badge, children, }) {
         open ? react_1.default.createElement(react_native_1.View, { style: styles.accordionBody }, children) : null));
 }
 /**
- * Small grey-text badge.  Marks sections / fields as "advanced",
- * "experimental", "legacy", or similar — quick visual signal that
- * the operator can usually ignore them.
+ * Small grey-text badge — marks sections as "advanced",
+ * "experimental", or similar.  No semantic effect; purely a quick
+ * visual signal.  Kept for future Layer-2 settings modals that may
+ * want to flag experimental sub-trees.
  */
 function Tag({ label }) {
     return (react_1.default.createElement(react_native_1.View, { style: styles.tag },
@@ -480,18 +324,21 @@ const styles = react_native_1.StyleSheet.create({
         marginTop: 18,
         marginBottom: 8,
     },
-    row: {
-        marginTop: 4,
+    // Nested-sub-section label inside an accordion body — used for the
+    // Flow-tunables sub-tree under Frame selection.
+    nested: {
+        marginTop: 12,
+        paddingTop: 12,
+        borderTopWidth: react_native_1.StyleSheet.hairlineWidth,
+        borderTopColor: 'rgba(255,255,255,0.08)',
     },
-    label: {
-        color: '#ffffff',
-        opacity: 0.85,
-        fontSize: 13,
+    nestedLabel: {
+        color: 'rgba(255,255,255,0.55)',
+        fontSize: 11,
         fontWeight: '600',
         textTransform: 'uppercase',
-        letterSpacing: 0.5,
-        marginTop: 18,
-        marginBottom: 8,
+        letterSpacing: 0.8,
+        marginBottom: 4,
     },
     segmentedRow: {
         flexDirection: 'row',
@@ -551,7 +398,6 @@ const styles = react_native_1.StyleSheet.create({
         fontSize: 14,
         fontWeight: '500',
     },
-    // V16 Phase 1b — Accordion + Tag + InfoBox
     accordion: {
         marginTop: 18,
         backgroundColor: 'rgba(255,255,255,0.04)',
@@ -596,16 +442,5 @@ const styles = react_native_1.StyleSheet.create({
         textTransform: 'uppercase',
         letterSpacing: 0.5,
     },
-    infoBox: {
-        backgroundColor: 'rgba(255,255,255,0.06)',
-        borderRadius: 8,
-        padding: 12,
-        marginTop: 4,
-    },
-    infoText: {
-        color: 'rgba(255,255,255,0.75)',
-        fontSize: 12,
-        lineHeight: 17,
-    },
 });
 //# sourceMappingURL=PanoramaSettingsModal.js.map